From 1c66fbd49f485702489e1ff170cf0180d169e347 Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Mon, 1 Dec 2008 14:19:22 +0000 Subject: [PATCH] *** empty log message *** --- Aster/Cata/cataSTA9/Macro/Sensibilite.py | 226 -- ...o_visu_meidee_ops.py => calc_essai_ops.py} | 105 +- .../cataSTA9/Macro/calc_europlexus_ops.py | 2407 +++++++++++++++++ Aster/Cata/cataSTA9/Macro/calc_modal_ops.py | 162 ++ Aster/Cata/cataSTA9/Macro/calc_spec_ops.py | 419 +++ Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py | 653 +++++ Aster/Cata/cataSTA9/Macro/test_temps_ops.py | 251 ++ Aster/prefs.py | 1 - 8 files changed, 3956 insertions(+), 268 deletions(-) delete mode 100644 Aster/Cata/cataSTA9/Macro/Sensibilite.py rename Aster/Cata/cataSTA9/Macro/{macro_visu_meidee_ops.py => calc_essai_ops.py} (69%) create mode 100644 Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py create mode 100644 Aster/Cata/cataSTA9/Macro/calc_modal_ops.py create mode 100644 Aster/Cata/cataSTA9/Macro/calc_spec_ops.py create mode 100644 Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py create mode 100644 Aster/Cata/cataSTA9/Macro/test_temps_ops.py diff --git a/Aster/Cata/cataSTA9/Macro/Sensibilite.py b/Aster/Cata/cataSTA9/Macro/Sensibilite.py deleted file mode 100644 index abd3f873..00000000 --- a/Aster/Cata/cataSTA9/Macro/Sensibilite.py +++ /dev/null @@ -1,226 +0,0 @@ -#@ MODIF Sensibilite Macro DATE 19/11/2007 AUTEUR COURTOIS M.COURTOIS -# -*- coding: iso-8859-1 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2007 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. -# ====================================================================== - -""" -Module traite de la gestion des concepts sensibles : - - classe permettant de stocker les noms des concepts et leurs dérivées - - corps de la macro MEMO_NOM_SENSI -""" - -# protection pour eficas -try: - import aster - from Utilitai.Utmess import UTMESS -except: - pass - -_VIDE_ = '????????' - -#------------------------------------------------------------------------------- -def _force_list(obj): - """Impose le type list.""" - if obj is not None and not type(obj) in (list, tuple): - obj = (obj,) - return obj - - -#------------------------------------------------------------------------------- -class MEMORISATION_SENSIBILITE: - """Classe pour la mémorisation des concepts sensibles et leurs dérivées. - """ - def __init__(self, debug=False): - """Initialisation de la structure - """ - self._debug = debug - # dictionnaire de correspondance : ('nom concept', 'nom parasensi') : 'nom compose' - self._corr = {} - # idem que _corr mais, pour les commandes principales, on stocke sd elle-meme - self._cosd = {} - self._nsnp = {} # l'inverse - # dictionnaire donnant les 3 tuples de mots-clés, valeurs, mots-clés facteurs - self._mcle = {} - - - def key(self, nosimp, nopase): - """Retourne la clé d'accès aux dictionnaires - """ - if not type(nosimp) in (str, unicode) or not type(nopase) in (str, unicode) or \ - len(nosimp.strip()) > 8 or len(nopase.strip()) > 8: - UTMESS('F', 'SENSIBILITE_57', valk=(nosimp, nopase)) - return nosimp.strip(), nopase.strip() - - - def set(self, nosimp, nopase, nocomp=None, limocl=None, livale=None, limofa=None, - verbose=False): - """On renseigne la structure de mémorisation : CHOIX='E' - """ - key = self.key(nosimp, nopase) - if self._corr.has_key(key): - UTMESS('F', 'SENSIBILITE_90', valk=(nosimp, nopase)) - limocl = _force_list(limocl) or () - livale = _force_list(livale) or () - limofa = _force_list(limofa) or () - if not (len(limocl) == len(livale) == len(limofa)): - UTMESS('F', 'SENSIBILITE_97') - - if nocomp is None: - nocomp = aster.get_nom_concept_unique('S') - # on ne conserve que le nom (au moins pour le moment) - if type(nocomp) != str: - sd = nocomp - nocomp = nocomp.nom - else: - sd = None - self._corr[key] = nocomp - self._cosd[nocomp] = sd - self._nsnp[nocomp] = key - self._mcle[key] = (limocl, livale, limofa) - - if verbose or self._debug: - UTMESS('I', 'SENSIBILITE_58', valk=(nosimp, nopase, nocomp)) - if len(limocl) != 0: - UTMESS('I', 'SENSIBILITE_59', valk=(str(limocl), str(livale), str(limofa))) - - - def get_nocomp(self, nosimp, nopase): - """On récupère le nom composé associé à un nom simple. - """ - key = self.key(nosimp, nopase) - nocomp = self._corr.get(key, _VIDE_) - if self._debug: - print ' memo_sensi.get_nocomp' - print ' nosimp, nopase = "%s", "%s"' % (nosimp, nopase) - print ' nom composé = "%s"' % nocomp - return nocomp - - - def get_nsnp(self, nocomp): - """On récupère le nom du concept et le parasensi associé au nom composé fourni. - """ - key = self._nsnp.get(nocomp, (_VIDE_, _VIDE_)) - if self._debug: - print ' memo_sensi.get_nsnp' - print ' nom composé = "%s"' % nocomp - print ' nosimp, nopase = "%s", "%s"' % key - return nocomp - - - def get_mcle(self, nosimp, nopase): - """On récupère les mots-clés associés à un couple ('nom concept', 'nom parasensi') - """ - key = self.key(nosimp, nopase) - tup3 = self._mcle.get(key, ((), (), ()) ) - if self._debug: - print tup3 - print ' memo_sensi.get_mcle nbmocl =',len(tup3[0]) - print ' nosimp, nopase = "%s", "%s"' % (nosimp, nopase) - print ' mots-clés = ', tup3 - return tup3 - - - def psinfo(self, nosimp): - """Pendant de l'ex-routine psnosd : retour selon le type de `nosimp`. - """ - # est-ce une structure dérivée ? - if nosimp in self._nsnp.keys(): - t_couples = self._nsnp[nosimp] - ideriv = 1 - else: - t_couples = self.get_deriv(nosimp) - ideriv = 0 - # on met le tuple des couples à plat : un tuple de longueur double - l_res = [] - for coupl in t_couples: - l_res.extend(coupl) - t_res = tuple(l_res) - if self._debug: - print ' memo_sensi.psinfo' - print ' nosimp = "%s"' % nosimp - print ' ideriv = ', ideriv - print ' result = ', t_res - return ideriv, t_res - - - def get_deriv(self, nosimp): - """On récupère la liste des couples ('nom composé', 'nom parasensi') associé à - un nom simple. - """ - res = [] - # liste des clés d'accès concernant `nosimp`. - l_key = [(ns, np) for ns, np in self._corr.keys() if ns == nosimp.strip()] - for ns, np in l_key: - res.append((self._corr[ns, np], np)) - return tuple(res) - - - def get_nom_sd_princ(self): - """Retourne la liste des noms des sd dérivées produites par les commandes principales. - """ - return tuple(self._cosd.keys()) - - - def delete(self, nosimp, nopase): - """On récupère les mots-clés associés à un couple ('nom concept', 'nom parasensi') - """ - key = self.key(nosimp, nopase) - nocomp = self.get_nocomp(nosimp, nopase) - if nocomp != _VIDE_: - del self._corr[key] - del self._cosd[nocomp] - del self._mcle[key] - del self._nsnp[nocomp] - - -#------------------------------------------------------------------------------- -#------------------------------------------------------------------------------- -def memo_nom_sensi_ops(self, NOM, **args): - """Macro MEMO_NOM_SENSI. - Transitoire : l'appel aux méthodes de MEMORISATION_SENSIBILITE devraient - à terme etre fait directement sans introduire de commandes MEMO_NOM_SENSI. - - Faut-il traiter les mots-clés NOM_ZERO et NOM_UN ? - Il me semble que NOM_COMPOSE est toujours présent : obligatoire - """ - import aster - - ier=0 - # La macro compte pour 1 dans la numerotation des commandes - self.set_icmd(1) - - dNOM = NOM[0].cree_dict_valeurs(NOM[0].mc_liste) - - nosimp = dNOM['NOM_SD'] - nopase = dNOM['PARA_SENSI'].nom - nocomp = dNOM['NOM_COMPOSE'] - - self.jdc.memo_sensi.set(nosimp, nopase, nocomp, - dNOM['MOT_CLE'], dNOM['VALEUR'], dNOM['MOT_FACT'], - verbose=True) - - # s'il faut déclarer le concept dérivé dans le jdc - if dNOM['TYPE_SD_DERIV']: - self.DeclareOut('nocomp', dNOM['NOM_COMPOSE']) - # enregistrement dans le tableau des concepts jeveux - icmdt = aster.co_register_jev(dNOM['NOM_COMPOSE'].nom, dNOM['TYPE_SD_DERIV'].upper(), 'MEMO_NOM_SENSI') - - return ier - - - diff --git a/Aster/Cata/cataSTA9/Macro/macro_visu_meidee_ops.py b/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py similarity index 69% rename from Aster/Cata/cataSTA9/Macro/macro_visu_meidee_ops.py rename to Aster/Cata/cataSTA9/Macro/calc_essai_ops.py index 7d817d30..7fdadf8d 100644 --- a/Aster/Cata/cataSTA9/Macro/macro_visu_meidee_ops.py +++ b/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macro_visu_meidee_ops Macro DATE 14/05/2008 AUTEUR BODEL C.BODEL +#@ MODIF calc_essai_ops Macro DATE 21/10/2008 AUTEUR NISTOR I.NISTOR # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2008 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 @@ -18,29 +18,31 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -## \package macro_visu_meidee_ops Implémentation de la macro MACRO_VISU_MEIDEE +## \package calc_essai_ops Implémentation de la macro CALC_ESSAI # -# Ce module contient la partie controle de la macro MACRO_VISU_MEIDEE +# Ce module contient la partie controle de la macro CALC_ESSAI # l'implémetation de cette macro se trouve dans les modules # meidee_help, meidee_mac, meidee_massamor, meidee_turbulent # on utilise aussi une librairie de support # pour la gestion de l'interface graphique dans meidee_iface -def macro_visu_meidee_ops( self, - INTERACTIF = None, - UNITE_FIMEN = None, - UNITE_RESU = None, - EXPANSION = None, - FLUIDE_ELASTIQUE = None, - TURBULENT = None, - MODIFSTRUCT = None, - GROUP_NO_CAPTEURS = None, - GROUP_NO_EXTERIEUR = None, - RESU_FLUDELA = None, - RESU_TURBULENT = None, - RESU_MODIFSTRU = None, - **args): +def calc_essai_ops( self, + INTERACTIF = None, + UNITE_FIMEN = None, + UNITE_RESU = None, + EXPANSION = None, + MEIDEE_FLUDELA = None, + MEIDEE_TURBULENT = None, + IDENTIFICATION = None, + MODIFSTRUCT = None, + GROUP_NO_CAPTEURS = None, + GROUP_NO_EXTERIEUR = None, + RESU_FLUDELA = None, + RESU_TURBULENT = None, + RESU_IDENTIFICATION = None, + RESU_MODIFSTRU = None, + **args): import aster from Meidee.meidee_cata import MeideeObjects ier = 0 @@ -62,15 +64,15 @@ def macro_visu_meidee_ops( self, out_modifstru = RESU_MODIFSTRU[0] # max=1 dans le capy - if not RESU_TURBULENT: - RESU_TURBULENT = [] + if not RESU_IDENTIFICATION: + RESU_IDENTIFICATION = [] else: - for res in RESU_TURBULENT: + for res in RESU_IDENTIFICATION: table_fonction.append(res['TABLE']) - out_turbulent = {"DeclareOut" : self.DeclareOut, - "TypeTables" : 'TABLE_FONCTION', - "ComptTable" : 0, - "TablesOut" : table_fonction} + out_identification = {"DeclareOut" : self.DeclareOut, + "TypeTables" : 'TABLE_FONCTION', + "ComptTable" : 0, + "TablesOut" : table_fonction} if not RESU_FLUDELA: RESU_FLUDELA = [] @@ -82,6 +84,14 @@ def macro_visu_meidee_ops( self, "ComptTable" : 0, "TablesOut" : table} + if not RESU_TURBULENT: + RESU_TURBULENT = [] + else: + for res in RESU_TURBULENT: + table.append(res['FONCTION']) + out_meideeturb = {"DeclareOut" : self.DeclareOut, + "FoncOut" : table} + # Mode interactif : ouverture d'une fenetre Tk if INTERACTIF == "OUI": @@ -89,7 +99,8 @@ def macro_visu_meidee_ops( self, UNITE_FIMEN, UNITE_RESU, out_fludela, - out_turbulent, + out_meideeturb, + out_identification, out_modifstru) else: from Meidee.meidee_calcul import MessageBox @@ -103,12 +114,14 @@ def macro_visu_meidee_ops( self, TestMeidee(self, mess, out_fludela, - out_turbulent, + out_meideeturb, + out_identification, out_modifstru, objects, EXPANSION, - FLUIDE_ELASTIQUE, - TURBULENT, + MEIDEE_FLUDELA, + MEIDEE_TURBULENT, + IDENTIFICATION, MODIFSTRUCT, GROUP_NO_CAPTEURS, GROUP_NO_EXTERIEUR @@ -149,8 +162,10 @@ def create_tab_mess_widgets(tk, UNITE_RESU): tabs = TabbedWindow(tabsw, ["Expansion de modeles", "Modification structurale", - "MEIDEE mono-modal", - "Identification de chargement"]) + "MEIDEE mono-modal fludela", + "MEIDEE mono-modal turbulent", + "Identification de chargement", + "Parametres de visualisation"]) tabs.grid(row=0, column=0, sticky='nsew') # pack(side='top',expand=1,fill='both') @@ -194,7 +209,8 @@ class FermetureCallback: def apply(self): """Enlève les fichiers temporaires de Xmgrace""" - self.turbulent.xmgr_manager.fermer() + if self.turbulent.param_visu.logiciel_courbes is not None: + self.turbulent.param_visu.logiciel_courbes.fermer() self.main_tk.quit() @@ -202,7 +218,8 @@ def create_interactive_window(macro, UNITE_FIMEN, UNITE_RESU, out_fludela, - out_turbulent, + out_meideeturb, + out_identification, out_modifstru): """Construit la fenêtre interactive comprenant une table pour les 4 domaines de Meidee.""" @@ -211,8 +228,9 @@ def create_interactive_window(macro, from Meidee.meidee_cata import MeideeObjects from Meidee.meidee_correlation import InterfaceCorrelation from Meidee.meidee_modifstruct import InterfaceModifStruct - from Meidee.meidee_fludela import InterfaceFludela + from Meidee.meidee_fludela import InterfaceFludela, InterfaceTurbMonomod from Meidee.meidee_turbulent import InterfaceTurbulent + from Meidee.meidee_parametres import InterfaceParametres # fenetre principale tk = Tk() @@ -226,20 +244,25 @@ def create_interactive_window(macro, objects = MeideeObjects(macro, mess) tabs.set_objects(objects) - iface = InterfaceCorrelation(main, objects, macro, mess) + param_visu = InterfaceParametres(main, mess) + + iface = InterfaceCorrelation(main, objects, macro, mess, param_visu) imodifstruct = InterfaceModifStruct(main, objects, macro, - mess, out_modifstru) - fludela = InterfaceFludela(main, objects, - get_fimen_files(UNITE_FIMEN), mess, out_fludela) - turbulent = InterfaceTurbulent(main, objects, mess, out_turbulent) + mess, out_modifstru, param_visu) + fludelamonomod = InterfaceFludela(main, objects, + get_fimen_files(UNITE_FIMEN), mess, out_fludela, param_visu) + turbmonomod = InterfaceTurbMonomod(main, objects,get_fimen_files(UNITE_FIMEN) ,mess, out_meideeturb, param_visu) + turbulent = InterfaceTurbulent(main, objects, mess, out_identification, param_visu) tabs.set_tab("Expansion de modeles", iface.main) tabs.set_tab("Modification structurale", imodifstruct.main) - tabs.set_tab("MEIDEE mono-modal", fludela ) + tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod ) + tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod ) tabs.set_tab("Identification de chargement", turbulent) + tabs.set_tab("Parametres de visualisation", param_visu) #tabs.set_current_tab("Modifstruct") - tabs.set_current_tab("Identification de chargement") + tabs.set_current_tab("Expansion de modeles") tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, turbulent).apply) diff --git a/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py new file mode 100644 index 00000000..6b3a4a82 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py @@ -0,0 +1,2407 @@ +#@ MODIF calc_europlexus_ops Macro DATE 24/11/2008 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 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 + +#----------------------------------------------------------------------- +#----------------------------- Importation des modules ---------------- +#----------------------------------------------------------------------- +debug = False +dryrun = False + +import types,string +import os +import Numeric as N +import math +import copy +import sets + +# Protection pour Eficas +try: + import aster + from Accas import _F + from Utilitai.partition import MAIL_PY +except: + pass + +#----------------------------- Precision ------------------------------- +tst = 1.0E-10 + +#----------------------------------------------------------------------- +#----------------------------- Fonctions de calcul vectoriel ----------- +#----------------------------------------------------------------------- + +def norme(u) : + return N.sqrt(N.dot(u,u)) + +def vecteurs_egaux(v1,v2): + diff = v1-v2 + #print 'v1',v1 + #print 'v2',v2 + for v in diff: + if abs(v) > tst : return False + return True + +#----------------------------------------------------------------------- +#----------------------------- Operateur de la Macro-commande ---------- +#----------------------------------------------------------------------- + + +def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None, + DIME=None,OBSERVATION=None,ARCHIVAGE=None,COURBE=None, + CALCUL=None,DOMAINES=None,INTERFACES=None,INFO=1,**args): + +# import aster +# from Accas import _F + + 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 + + global _F,INFO_EXEC_ASTER,DETRUIRE,IMPR_RESU,DEFI_FICHIER,LIRE_RESU,CREA_MAILLAGE + global DEFI_GROUP,LIRE_MAILLAGE,CREA_TABLE,IMPR_TABLE,AFFE_MODELE,EXEC_LOGICIEL + global LIRE_CHAMP,CREA_CHAMP,CREA_RESU,FORMULE + + INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER') + DETRUIRE = self.get_cmd('DETRUIRE') + IMPR_RESU = self.get_cmd('IMPR_RESU') + DEFI_FICHIER = self.get_cmd('DEFI_FICHIER') + LIRE_RESU = self.get_cmd('LIRE_RESU') + CREA_MAILLAGE = self.get_cmd('CREA_MAILLAGE') + DEFI_GROUP = self.get_cmd('DEFI_GROUP') + LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') + CREA_TABLE = self.get_cmd('CREA_TABLE') + IMPR_TABLE = self.get_cmd('IMPR_TABLE') + AFFE_MODELE = self.get_cmd('AFFE_MODELE') + EXEC_LOGICIEL = self.get_cmd('EXEC_LOGICIEL') + LIRE_CHAMP = self.get_cmd('LIRE_CHAMP') + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + CREA_RESU = self.get_cmd('CREA_RESU') + FORMULE = self.get_cmd('FORMULE') + + # Pour la gestion des Exceptions + prev_onFatalError = aster.onFatalError() + aster.onFatalError('EXCEPTION') + + + # Pour masquer certaines alarmes + from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme + MasquerAlarme('MED_1') + + # Ligne de commande d'Europlexus + if args.has_key('LOGICIEL'): EXEC = args['LOGICIEL'] + else: EXEC = '/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d' + if debug: print 'args_keys : %s'%args.keys() + if args.has_key('PAS_NBRE_COURBE') : + if debug: print 'PAS NBRE COURBE = ok (%s)'%args['PAS_NBRE_COURBE'] + else : + if debug: print 'PAS NBRE COURBE = nook' + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # classs Europlexus permettant de faire le chainage avec le Code_Aster + EPX = EUROPLEXUS(MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME, +# AA ECRITURE,CALCUL,REPE='REPE_OUT',EXEC=EXEC) + OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES, + REPE='REPE_OUT',EXEC=EXEC, INFO=INFO, args=args) + + # Eriture du fichier de commande Europlexus + EPX.ecrire_fichier() + + # Si dryrun alors on ne lance pas le calcul Europlexus + if dryrun: return ier + + # Lancement du calcul Europlexus + EPX.lancer_calcul() + + # Recuperer le resulat Europlexus a l'aide d'un concept aster de type evol_noli + fichier_med = 'auto' + fichier_pun = 'auto' +# if debug : +# fichier_med='fort.81' +# fichier_pun ='fort.85' + + self.DeclareOut('resu',self.sd) # Le concept sortant (de type evol_noli) est nomme 'resu' + global resu # pour que le nom du concept prenne celui defini par l'utilisateur + EPX.get_resu(fichier_med=fichier_med) + + #Recuperer les concepts table + if COURBE is not None: + global table + # icourbe = 0 + # for fonc in COURBE['TABLE'] : + # icourbe += 1 + self.DeclareOut('table',args['TABLE_COURBE']) + EPX.get_table() + # EPX.get_table(icourbe=icourbe,fichier=fichier_pun) + + + # Pour la gestion des Exceptions + aster.onFatalError(prev_onFatalError) + + # Pour la gestion des alarmes + RetablirAlarme('MED_1') + + return ier + +#----------------------------------------------------------------------- +#----------------------------- class EUROPLEXUS ------------------------ +#----------------------------------------------------------------------- + +class EUROPLEXUS: +# AA def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,ECRITURE,CALCUL,REPE,EXEC,**args): + def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES,REPE,EXEC,INFO,args): + + if debug: print 'args_key %s'%args.keys() + # Mettre toutes les entrees en attributs + self.DIME = DIME + self.MODELE = MODELE + self.CARA_ELEM = CARA_ELEM + self.CHAM_MATER = CHAM_MATER + self.FONC_PARASOL = FONC_PARASOL + self.EXCIT = EXCIT +# self.ECRITURE = ECRITURE + self.OBSERVATION = OBSERVATION + self.ARCHIVAGE = ARCHIVAGE + self.COURBE = COURBE + self.CALCUL = CALCUL + self.DOMAINES = DOMAINES + self.INTERFACES = INTERFACES + self.INFO = INFO + + # Repertoire de calcul Europlexus + self.REPE = REPE + # Commande d'execution de Europlexus + self.EXEC = EXEC + + if args.has_key('UNITE_COURBE'): self.UNITE_COURBE = args['UNITE_COURBE'] + else: self.UNITE_COURBE = None + + if args.has_key('PAS_INST_COURBE'): self.PAS_INST_COURBE = args['PAS_INST_COURBE'] + else: self.PAS_INST_COURBE = None + + if args.has_key('PAS_NBRE_COURBE'): self.PAS_NBRE_COURBE = args['PAS_NBRE_COURBE'] + else: self.PAS_NBRE_COURBE = None + + if args.has_key('TABLE_COURBE'): self.TABLE_COURBE = args['TABLE_COURBE'] + else: self.TABLE_COURBE = None + # Dictionnaire contenant le texte associé au fichier de commande Europlexus + self.epx = {} + + if debug: print 'pas nbre courbe = %s'%self.PAS_NBRE_COURBE + + # Concept pour un nouveau maillage si on utilise RIGI_PARASOL ou + # si on regroupe separement les mailles tria3 et quad4 + self.NEW_MA = None + + # Nom des fichiers de Europlexus (commande et sorties) + self.nom_fichiers = {'COMMANDE' : 'commandes.epx', + 'MAILLAGE' : 'maillage_epx', + 'ALIT' : 'champ.alit', + 'MED' : 'champ.e2m', + 'PUN' : 'courbes.pun', + } + + # Chemin du repertoire courant ou le calcul Aster est lance + self.pwd = os.getcwd() + os.sep + + + +#----------------------------------------------------------------------- + def get_unite_libre(self,): + + _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE') + unite=_UL['UNITE_LIBRE',1] + DETRUIRE(CONCEPT=(_F(NOM=_UL),), INFO=1) + return(unite) + + +#----------------------------------------------------------------------- + def reupere_structure(self,concept,mot_cle=None): + + try : structure = concept.etape.valeur + except : UTMESS('F','PLEXUS_1') + + if mot_cle : + if structure.has_key(mot_cle) : return structure[mot_cle] + else : return None + return structure +#----------------------------------------------------------------------- + def get_motcle(self,fact,mot_cle,code_mess='F'): + try : + out = fact[mot_cle] + except : + out = None + if not out is None : return out + if not code_mess is None and code_mess: UTMESS(code_mess,'PLEXUS_2',valk=mot_cle) + return None + +#----------------------------------------------------------------------- + def get_group_ma(self,fact): + group_ma = self.get_motcle(fact,'GROUP_MA',code_mess='F') + if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,) + # elif types.TypeType(group_ma) == types.ListType : group_ma = tupel(group_ma) + return group_ma + +#----------------------------------------------------------------------- + def get_group_ma_f(self,fact): + group_ma = self.get_motcle(fact,'GROUP_MA',None) + if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,) + # elif types.TypeType(group_ma) == types.ListType : group_ma = tupel(group_ma) + if not group_ma : group_ma=[] + return group_ma + +#----------------------------------------------------------------------- + def setlist(self,fact): + #print 'types.TypeType(fact)',types.TypeType(fact) + if fact is None : return fact + if not types.TypeType(fact) in [types.ListType,types.TupleType] : fact= [fact] + return fact + +#----------------------------------------------------------------------- + def lire_fichier(self,fichier,): + fd = open(fichier,'r') + lignes = fd.readlines() + fd.close() + valeurs = [] + commentaires = ['#','%','$','*'] + for ll in lignes: + add = 1 + for comment in commentaires : + if string.find(ll,comment) != -1 : add = 0;break + if add : + data = [val for val in ll.split(None)] + valeurs.append(data) + return valeurs + +#----------------------------------------------------------------------- + def fichier2dic(self,fichier): + valeurs = self.lire_fichier(fichier) + dic = {} + mot_cle = None + for ll in valeurs: + if len(ll) > 1 : + for mot in ll : + try : + val = float(mot) + if not mot_cle is None : dic[mot_cle].append(val) + except : + mot_cle = mot + dic[mot_cle] = [] + + return dic + +#----------------------------------------------------------------------- + def lire_pun(self,fichier): + if debug: print 'lire_pun : fichier = %s'%fichier + data = self.lire_fichier(fichier) + icourbe = 0 + courbes = {} + for ligne in data: + if debug: print 'lire_pun : %s'%ligne + if ligne[0] in ('VALEURS','VALUES'): + icourbe += 1; + nb = int(ligne[1]) + courbes[icourbe] = [] + else: + ligne_vale = [float(val) for val in ligne] + courbes[icourbe].append(ligne_vale) + for courbe in courbes : + courbes[courbe]=N.transpose(N.array(courbes[courbe])) + return courbes + +#----------------------------------------------------------------------- + def export_DEBUT(self): + + epx = self.epx + + # Cle identifiant + MODULE = 'DEBUT' + + # Entete de la commande Europlexus courante + epx[MODULE] = ['*--FICHIER CREE PAR CALC_EUROPLEXUS/Code_Aster'] + + # Texte declarant le debut + epx[MODULE].append('TITRE') + epx[MODULE].append('ECHO') + options = 'TRID NONL' +# AA champ_fact = self.ECRITURE['CHAMP'] + champ_fact = self.ARCHIVAGE + if champ_fact is not None : options += ' MEDE' + epx[MODULE].append(options) + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def export_MAILLAGE(self,format='CASTEM'): + + epx = self.epx + + # Cle identifiant + MODULE = 'MAILLAGE' + + # Entete de la commande Europlexus courante + epx[MODULE] = ['*--LECTURE MAILLAGE'] + + # Recuperer la concept maillage modifie ou initial + if self.NEW_MA is None : + concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + else : + concept_maillage = copy.copy(self.NEW_MA) + + # Ecrire le maillage, qui peut etre a ete enrichi avec des commandes Aster, sous le format souhaite (MED ou CASTEM) + unite = self.get_unite_libre() + + # Extensions des formats de maillage + extension = {'CASTEM' : '.mgib', 'MED':'.med'} + + # donner un nom au fichier de maillage parce que le fort.unite peut etre ecrase par d'autre operation d'ecriture + nom_fichier = self.REPE + os.sep + self.nom_fichiers['MAILLAGE'] + extension[format] + DEFI_FICHIER(UNITE=unite,FICHIER=nom_fichier,ACTION='ASSOCIER') + IMPR_RESU(UNITE=unite, + FORMAT=format, + RESU = _F(MAILLAGE=concept_maillage) + ) + DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); + + # Ecriture de la commande Europlexus associee + fichier_maillage = self.pwd + nom_fichier + + #epx[MODULE].append('OPNF FORMAT 9') + epx[MODULE].append('%s '%format) + epx[MODULE].append("'%s' TOUT" %fichier_maillage) + #epx[MODULE].append('CASTEM 9 TOUT') + + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def export_DIME(self,): + epx = self.epx + + # Cle identifiant + MODULE = 'DIME' + + # Entete de la commande Europlexus courante + epx[MODULE] = ['*--DIMENSIONNEMENT'] + epx[MODULE].append('\n') + + # Test si des parametres de dime seront introuduites à l'aide d'un fichier externe + try : unite_dime = self.DIME['UNITE_DIME'] + except : unite_dime = None + + # Recuperer le dictionnaire issu du fichier associe à UNITE_DIME (s'il existe) + if unite_dime is not None : + fort = 'fort.%i' %unite_dime + dic_fichier = self.fichier2dic(fort) + else: + dic_fichier = {} + + # mettre a jour les cles definis dans le fichier par celles qui sont + # definies directement sous le mot-cle facteur DIME + cles = ['Q4GS', 'FORCE', 'PT6L', 'ZONE', 'POUT', + 'ECRO', 'APPU', 'BLOQ', 'PRESS', 'PMAT', + 'FTAB', 'DKT3', 'DEPL', 'FNOM', 'TABLE', + 'LIAI', 'MTTI', 'PT1L','NEPE'] + + for cle in cles: + try: + if self.DIME[cle] is not None : + dic_fichier[cle] = self.DIME[cle] + except : pass + + # Imprimer les mot-cles et leurs dans epx + epx[MODULE].append('DIME') + for cle in dic_fichier: + vale = dic_fichier[cle] + st = 5*' ' + cle + for v in vale: + st += ' %i' %v + epx[MODULE].append(st) + epx[MODULE].append('TERM') + + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def export_MODELE(self): + + epx = self.epx + + # Cle identifiant + MODULE = 'MODELE' + + epx[MODULE] = ['*--DEFINITION DE LA GEOMETRIE'] + + # Entete de la commande Europlexus courante + epx[MODULE].append('GEOMETRIE') + + # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MODELE + affe_modele = self.reupere_structure(self.MODELE,'AFFE') + affe_modele = self.setlist(affe_modele) + + + # Correspondance de modelisation aster/europlexus + dic_modele = {'DKT':'DKT3','DKTG':'Q4GS','POU_D_E':'POUT'} + + # Correspondance de modelisation europlexus/aster + dic_modele_epx = {} + for cle in dic_modele.keys(): + dic_modele_epx[dic_modele[cle]] = cle + + # initialisation du dictioannaire qui contient les group_ma en fonction de la modelisation + dic_gma = {} + for cle in dic_modele.values(): + dic_gma[cle] = [] + + for affe in affe_modele: + modelisation = affe['MODELISATION'] + phenomene = affe['PHENOMENE'] + if phenomene == 'MECANIQUE' and modelisation in dic_modele.keys(): + if affe.has_key('GROUP_MA') : + group_ma = self.get_group_ma(affe) + dic_gma[dic_modele[modelisation]].extend(group_ma) + else : + UTMESS('F','PLEXUS_3') + + # Regrouper separement les mailles tria3 et quad4 de la modilisation DKT (s'il y a lieu) + # parce que leurs modilisations dans europlexus sont differentes: + # tria3 : DKT3 + # quad4 : Q4GS + + # Initialisation du dictionnaire contenant les elements du modele de type TRIA3 et QUAD4 + nom_groups= {'TRIA3':[],'QUAD4':[]} + + if len(dic_gma['DKT3']) > 0: + concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + class_dkt = DKT(MAILLAGE=concept_maillage,) + nom_groups = class_dkt.aster2epx(groups=dic_gma['DKT3']) + if debug: print 'nom_groups = %s'%nom_groups + # mettre a jour les groups de chaque modelisation + dic_gma['DKT3'] = nom_groups['TRIA3'] + dic_gma['Q4GS'].extend(nom_groups['QUAD4']) + + + # liste comportant les modelisations definis dans le module GEOMETRIE + # cette liste va servir à determiner les indices des champs stockes dans le fichier med (get_resu) + self.modelisations = [] + # Ecriture sous format europlexus + for modelisation in dic_gma.keys() : + len_groups = len(dic_gma[modelisation]) + if len_groups > 0 : + self.modelisations.append(modelisation) + epx[MODULE].append(5*' ' + modelisation + 2*' ' + dic_gma[modelisation][0]) + if len_groups > 1 : + for ig in range(1,len_groups) : + group_ma = dic_gma[modelisation][ig] + epx[MODULE].append((len(modelisation)+5+2)*' ' + group_ma) + + + + # Mettre a jour le modele dans le cas ou le maillage a ete modifie pour la seperation de TRIA3 et QUAD4 + # ce modele va etre utilise dans la lecture du fichier med (get_resu) + if len(nom_groups['QUAD4']) == 0 : + self.NEW_MODELE = copy.copy(self.MODELE) + else : + affe_model = [] + for modelisation in self.modelisations : + affe_model.append({'GROUP_MA':dic_gma[modelisation], + 'MODELISATION': dic_modele_epx[modelisation], + 'PHENOMENE':'MECANIQUE' }) + + __MO = AFFE_MODELE(MAILLAGE = concept_maillage, + AFFE = affe_model, + ); + + self.NEW_MODELE = copy.copy(__MO); + + # Utiliser dans Ecriture des elements et points du fichier med + self.dic_gma = dic_gma + # Il y a une suite dans RIGI_PARSOL + + #epx[MODULE].append('TERM') + #epx[MODULE].append('\n') + + + #----------------------------------------------------------------------- + def export_CARA_ELEM(self): + + epx = self.epx + + # Cle identifiant + MODULE = 'CARA_ELEM' + + # Recuperer la structure du concept sorti de AFFE_CARA_ELEM + cara_elem_struc = self.reupere_structure(self.CARA_ELEM) + + epx[MODULE] = ['*--CARACTERISTIQUES DES ELEMENTS DE STRUCTURE'] + + # Entete de la commande Europlexus courante + epx[MODULE].append('COMPLEMENT') + + # Dictionnaire conteant les donnees associees aux differents elements de structure + dic_elem = {} + for cle in ['DISCRET','COQUE','POUTRE','RIGI_PARASOL']: + if cara_elem_struc.has_key(cle): + fact = cara_elem_struc[cle] + if fact : + dic_elem[cle] = self.setlist(fact) + + # traduire les masses concentrees si elles existent + cle = 'DISCRET' + self.discretParasol = {} + if dic_elem.has_key(cle): + epx[MODULE].append('\n') + epx[MODULE].append('*--MASSES AJOUTEES') + for elem in dic_elem[cle]: + if elem['CARA'] == 'M_T_D_N' : + group_ma = self.get_group_ma(elem) + vale = elem['VALE'] + epx[MODULE].append('MASSE 123456 %g' %vale) + epx[MODULE].append(7*' ' + 'LECT') + for group in group_ma: + epx[MODULE].append(11*' '+group) + epx[MODULE].append(7*' ' + 'TERM') + if elem['CARA'] == 'K_TR_D_N' : + group_ma = self.get_group_ma(elem) + vale = elem['VALE'] + for gma in group_ma : + self.discretParasol[gma] = vale + + # traduire les elements coques s'ils existent + cle = 'COQUE' + self.dicOrthotropie={} + self.listEpais=[] + self.listEpais2=[] + if dic_elem.has_key(cle): + epx[MODULE].append('\n') + epx[MODULE].append('*--ELEMENTS COQUES') + for elem in dic_elem[cle]: +# print elem + group_ma = self.get_group_ma(elem) + epais = elem['EPAIS'] + if self.ARCHIVAGE['CONT_GENER'] == 'OUI' : + self.listEpais.append({'VALE' : epais, 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'}) + self.listEpais2.append({'VALE' : epais**2/6., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'}) + else : + self.listEpais.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'}) + self.listEpais2.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'}) + st = 'EPAIS %g ' %epais + #ajouter les group_ma qui ont ete affecte par ces caracteristiques + epx[MODULE].append(st+'LECT') + for group in group_ma: + epx[MODULE].append((len(st)+4)*' '+group) + epx[MODULE].append((len(st))*' '+'TERM') + if elem.has_key('VECTEUR'): +# AA if elem['VECTEUR'] : + for group in group_ma : + self.dicOrthotropie[group] = elem['VECTEUR'] + + # traduire les elements poutres s'ils existent + cle = 'POUTRE' + if dic_elem.has_key(cle): + concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + #class permettant de calculer et verifier les vecteurs de poutre dans Europlexus + class_poutre = POUTRE(MAILLAGE=concept_maillage,CARA_ELEM=self.CARA_ELEM) + epx[MODULE].append('\n') + epx[MODULE].append('*--ELEMENTS POUTRES') + for elem in dic_elem[cle]: + group_ma = self.get_group_ma(elem) + vecteurs = class_poutre.getvecteurs(group_ma,verif='non') + vect_y = vecteurs[group_ma[0]] + type_section = elem['SECTION'] + st = 'GEOP %s ' %type_section + if type_section == 'RECTANGLE' : + # Correspondance de caracteristique de poutre aster/europlexus + dic_corresp = {'HY':'AY','HZ':'AZ'} + epx[MODULE].append(st) + # ajouter le vecteur definisant l'orientation de la section + epx[MODULE].append(len(st)*' ' + 'VX %g' %vect_y[0]) + epx[MODULE].append(len(st)*' ' + 'VY %g' %vect_y[1]) + epx[MODULE].append(len(st)*' ' + 'VZ %g' %vect_y[2]) + # ajouter les caracteristiques de la poutre + cara = elem['CARA'] + vale = elem['VALE'] + for icar in range(len(cara)): + car = cara[icar] + val = vale[icar] + car_epx = dic_corresp[car] + epx[MODULE].append(len(st)*' ' + '%s %g' %(car_epx,val)) + # ajouter les group_ma qui ont ete affecte par ces caracteristiques + epx[MODULE].append(5*' '+'LECT') + for group in group_ma: + epx[MODULE].append(len(st)*' '+group) + epx[MODULE].append(5*' '+'TERM') + else : + UTMESS('A','PLEXUS_4',valk=type_section) + + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def export_RIGI_PARASOL(self): + + epx = self.epx + + # Cle identifiant + MODULE = 'RIGI_PARASOL' + concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + self.MApyt = MAIL_PY() + self.MApyt.FromAster(concept_maillage) + + # Recuperer la structure du concept sorti de AFFE_CARA_ELEM + cara_elem_struc = self.reupere_structure(self.CARA_ELEM) + + # Recuperer la structure RIGI_PARASOL si elles existe + list_rigi_parasol = None + if cara_elem_struc.has_key('RIGI_PARASOL'): + fact = cara_elem_struc['RIGI_PARASOL'] + if fact :list_rigi_parasol = self.setlist(fact) + + # Traduction des fonctions definies dans FONC_PARASOL + #dic_fonc_parasol = self.get_FONC_PARASOL(list_rigi_parasol) + dic_fonc_parasol = self.get_FONC_PARASOL() + epx[MODULE] = ['*--SUPPORT ELASTIQUE'] + + # si l'utilisateur a lui meme fourni des GROUP_MA de discrets : on commence par la + gmaParasol=self.get_group_ma_f(self.FONC_PARASOL) + group_union = '' + for gma in gmaParasol : + if gma not in self.discretParasol : + if debug: print gma + if debug: print self.discretParasol.keys() + raise 'Discret non defini' + vale = self.discretParasol[gma] + epx[MODULE].append('SUPPORT') + epx[MODULE].append(6*' '+'KX %g KY %g KZ %g'%(vale[0],vale[1],vale[2])) + epx[MODULE].append(6*' '+'KRX %g KRY %g KRZ %g'%(vale[3],vale[4],vale[5])) + for cle_fonc_parasol in dic_fonc_parasol.keys() : + epx[MODULE].append(6*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) ) + epx[MODULE].append(6*' '+'LECT %s TERM'%gma) + group_union += '%s '%gma + if len(gmaParasol) > 0 : + epx['MODELE'].append(5*' ' + 'APPU ' + group_union) + + # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + # DEFI_GROUP(reuse = concept_maillage, + # MAILLAGE = concept_maillage, + # CREA_GROUP_NO = _F(GROUP_MA = gmaParasol), + # ); + + + + # traduire les rigi_parasol + if list_rigi_parasol : + # changement de module parce que les supports issus de RIGI_PARASOL doivent etre imprimes apres les materiaux + # fichiers_parasol = [] + # cles_oblig = ['UNITE_EUROPLEXUS','GROUP_MA_POI1'] + # for elem in list_rigi_parasol: + # elem_cara = elem['CARA'] + # if elem_cara == 'K_TR_D_N': + # for cle_test in cles_oblig: + # if not elem.has_key(cle_test): + # pass + # unite = elem['UNITE_EUROPLEXUS'] + # fichier = 'fort.%i' %unite + # if fichier not in fichiers_parasol : fichiers_parasol.append(fichier) + # else : + # pass + # Lecture des valeurs de rigidites generees par aster a partir des rigidites globales definis dans PARA_RIGISOL + # ressorts = [] + # for fichier in fichiers_parasol : + # ressorts.extend(self.lire_fichier(fichier)) + ressorts = self.CARA_ELEM.toEPX() + # Creer un maillage qui, pour chaque noeud de l'interface utilisee dans rigi_parsol, asscocie un group_ma asscie + # parce que on n'a pas les memes numeros des noeuds dans Europlexus + crea_poi1 = [] + dic_gma = {} + igr = -1 + # Liste des group_ma associes au noeuds ou le RIGI_PARSOL a ete applique + groups_parasol = [] + + for noeud in ressorts.keys() : + # noeud = ressor[0] + if not dic_gma.has_key(noeud): + igr += 1 + group_ma = 'SUP%i' %igr + dic_gma[noeud] = group_ma + groups_parasol.append(group_ma) + crea_poi1.append(_F(NOEUD=noeud,NOM_GROUP_MA=group_ma)) + + # ATTENTION : a deplacer + # crea_maillage a faire de facon centraliser pour RIGI_PARASOL et le POST-TRAITEMENT ailleurs + courbe_fact = self.COURBE + if courbe_fact is None: courbe_fact = [] + lnoeuds=sets.Set([]) + lmailles=sets.Set([]) + dicma=[] + for courbe in courbe_fact : + if courbe['GROUP_NO'] != None : + noeuds = courbe['GROUP_NO'] + if type(noeuds) == tuple : + for el in noeuds : + lnoeuds.add(el) + else : + lnoeuds.add(noeuds) + if courbe['GROUP_MA'] != None : + mailles = courbe['GROUP_MA'] + if type(mailles) == tuple : + for el in mailles : + lmailles.add(el) + else : + lmailles.add(mailles) + for maille in lmailles : + dicma.append({'NOM' : maille, 'MAILLE' : maille}) + + for no in lnoeuds : + if not self.MApyt.gno.has_key(no) : + crea_poi1.append(_F(NOEUD=no,NOM_GROUP_MA=no)) + + __NEW = CREA_MAILLAGE(MAILLAGE=concept_maillage, + CREA_POI1 = crea_poi1, + ); + self.NEW_MA = copy.copy(__NEW) + + # Ecriture sous format europlexus + # Indices des composantes + indices_comps = {'KX':1,'KY':2,'KZ':3,'KRX':4,'KRY':5,'KRZ':6} + for noeud in ressorts : + valeurs = ressorts[noeud] + epx[MODULE].append('SUPPORT') + # ecriture des composantes et de leurs valeurs associees + for comp in indices_comps.keys(): + if debug: print len(valeurs),indices_comps[comp]-1 + vale = valeurs[indices_comps[comp]-1] + epx[MODULE].append(3*' ' + '%s %s' %(comp,vale)) + # caracteristiques des translations et des rotations + for cle_fonc_parasol in dic_fonc_parasol.keys() : + epx[MODULE].append(3*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) ) + + # ecriture du group_ma associe + # noeud = ressor[0] + group_ma = dic_gma[noeud] + epx[MODULE].append(3*' ' + 'LECT %s TERM' %group_ma) + + epx[MODULE].append('\n') + + group_union = 'PARASOL' + dicma.append({'NOM' : group_union, 'UNION' : groups_parasol}) + __NEW = DEFI_GROUP(reuse = __NEW, + MAILLAGE = __NEW, + CREA_GROUP_MA = dicma + ) + + # Mettre a jour le module modele qd les ressots existent + epx['MODELE'].append(5*' ' + 'APPU ' + group_union) + # Fermer le module modele dans tous les cas + self.multidomaine = 0 + listInterfaces = self.INTERFACES + self.gmaInterfaces=[] + if listInterfaces : + i=0 + self.multidomaine = 1 + for interface in listInterfaces : + Lgma1 = self.setlist(interface['GROUP_MA_1']) + Lgma2 = self.setlist(interface['GROUP_MA_2']) + self.gmaInterfaces.extend(Lgma1) + self.gmaInterfaces.extend(Lgma2) + for gma in Lgma1 : + if i==0 : + epx['MODELE'].append(5*' ' + 'CL3L' + 2*' ' + gma) + else : + epx['MODELE'].append(11*' ' + gma) + for gma in Lgma2 : + epx['MODELE'].append(11*' ' + gma) + i+=1 + epx['MODELE'].append('TERM') + epx['MODELE'].append('\n') + + if self.gmaInterfaces : + epx['CHAM_MATER'].append('FANTOME 0. LECT') + for gma in self.gmaInterfaces : + epx['CHAM_MATER'].append(15*' '+'%s'%gma) + epx['CHAM_MATER'].append(' TERM') + epx['CHAM_MATER'].append('\n') + + + # DEFINITION REPERES ORTHOTROPIE QUI DOIT ETRE APRES LES SUPPORTS + for gma in self.gmaGLRC : + if gma not in self.dicOrthotropie : + raise "Erreur : %s non affecte par un repere d'orthotropie : ajouter le mot-cle 'VECTEUR' dans AFFE_CARA_ELEM"%gma + vale = self.dicOrthotropie[gma] + epx[MODULE].append('COMP ORTS %g %g %g'%(vale[0],vale[1],vale[2])) + epx[MODULE].append(3*' '+'LECT') + epx[MODULE].append(7*' '+'%s'%gma) + epx[MODULE].append(3*' '+'TERM') + + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def get_FONC_PARASOL(self,list_rigi_parasol=None) : + + epx = self.epx + + MODULE = 'FONC_PARASOL' + if list_rigi_parasol is not None : + if self.FONC_PARASOL is None : UTMESS('F','PLEXUS_12') + # else : return None + + epx[MODULE] = ['*--DEFINITIONS DES FONCTIONS'] + + # Entete de la commande europlexus + epx[MODULE].append('FONC') + + # Cles de FONC_PARASOL dans l'ordre + cles = ['NFKT','NFKR'] + # Dictionnaire faisant la correspondance entre la fonction et son numero europlexus + dic_fonc = {} + try : + ifonc = self.ifonc + if debug: print 'self.ifonc = %s'%ifonc + except : + self.ifonc=0 + ifonc = self.ifonc + if debug: print 'ifonc = %s'%ifonc + if epx.has_key('FONC_MATER') : + epx[MODULE].extend(epx['FONC_MATER']) + for cle in cles: + ifonc += 1 + dic_fonc[cle] = ifonc + fonction = self.get_motcle(self.FONC_PARASOL,cle,code_mess='A') + (temps,valeurs) = fonction.Valeurs() + # imprimer les valeurs de la table + epx[MODULE].append(5*' ' +'NOPA %i TABLE %i' %(ifonc,len(temps)) ) + for ival in range(len(temps)): + epx[MODULE].append(17*' ' +'%g %g' %(temps[ival],valeurs[ival])) + self.ifonc = ifonc + self.dic_fonc = dic_fonc + epx[MODULE].append('\n') + return dic_fonc + +#----------------------------------------------------------------------- + def export_CHAM_MATER(self): + + epx = self.epx + + # CLe identifiant + MODULE = 'CHAM_MATER' + + epx[MODULE] = ['*--DEFINITION DES MATERIAUX'] + + # Entete de la commande Europlexus courante + epx[MODULE].append('MATERIAUX') + + # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MATER + affe_mater = self.reupere_structure(self.CHAM_MATER,'AFFE') + affe_mater = self.setlist(affe_mater) + + # Dictionnaire stoquant les caracteristiques mecaniques et les group_ma associe a chaque materiau + dic_mater = {} + typMat = {} + # GLRC impose de définir l'orientation : on stocke dans gmaGLRC les GMA dont il faudra retrouver l'orientation dans MODI_MAILLAGE/ORIE_NORM_COQUE + self.gmaGLRC = [] + epx['FONC_MATER'] = [] + ref_fonc=[] + for affe in affe_mater : + # Recuperer le concept du materiau defini par DEFI_MATERIAU + concept_mater = affe['MATER'] + # Recuperer le nom du materiau + nom_mater = concept_mater.get_name() + # Recuperer le group_ma concerne + group_ma = self.get_group_ma(affe) + if debug: print 'type(group_ma) = %s'%type(group_ma) + if not dic_mater.has_key(nom_mater): + dic_mater[nom_mater] = {'GROUP_MA':[]} + # Recuperer les caracteristiques elastiques du materiau + elas = self.reupere_structure(concept_mater,'ELAS') + if elas : + typMat[nom_mater] = 'ELAS' + for car in ['E','RHO','NU']: + dic_mater[nom_mater][car] = elas[car] + for car in ['AMOR_ALPHA','AMOR_BETA'] : + if elas.has_key(car) : + dic_mater[nom_mater][car] = elas[car] + else : + dic_mater[nom_mater][car] = None + beton = self.reupere_structure(concept_mater,'BETON') + if beton : + typMat[nom_mater] = 'GLRC' + self.gmaGLRC.extend(group_ma) + dic_mater[nom_mater]['LINER']=[] + dic_mater[nom_mater]['NAPPE']=[] + materBeton = beton['MATER'] + elasBeton = self.reupere_structure(materBeton,'ELAS') + dic_mater[nom_mater]['BETON']={} + for car in ['E','RHO','NU']: + dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car) + for car in ['AMOR_ALPHA','AMOR_BETA']: + dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car,None) + ecroBeton = self.reupere_structure(materBeton,'BETON_ECRO_LINE') + for car in ['SYT','SYC']: + dic_mater[nom_mater]['BETON'][car] = self.get_motcle(ecroBeton,car,None) + for car in ['EPAIS','GAMMA','QP1','QP2','C1N1','C1N2','C1N3','C2N1','C2N2','C2N3','C1M1','C1M2','C1M3','C2M1','C2M2','C2M3'] : + dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car) + for car in ['OMT','EAT','BT1','BT2'] : + dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car,None) + for car in ['MP1X','MP1Y','MP2X','MP2Y'] : + car_temp = self.get_motcle(beton,car,None) + if debug: print 'type(car_temp) = %s'%type(car_temp) + dic_mater[nom_mater]['BETON'][car] = None + if car_temp : + if type(car_temp) == float : + dic_mater[nom_mater]['BETON'][car] = car_temp + else : + if debug: print dir(car_temp) + try : + ifonc = self.ifonc + except : + self.ifonc=0 + ifonc = self.ifonc + ifonc += 1 + val = car_temp.Valeurs() + x = val[:len(val):2] + y = val[1:len(val):2] + # imprimer les valeurs de la table + epx['FONC_MATER'].append(5*' ' +'%i LSQU 2 TABLE %i' %(ifonc,len(x)) ) + for ival in range(len(x)): + epx['FONC_MATER'].append(17*' ' +'%g %g' %(x[ival],y[ival])) + dic_mater[nom_mater]['BETON'][car] = 'FONC %i'%ifonc + self.ifonc=ifonc + + + cable = self.reupere_structure(concept_mater,'CABLE_PREC') + if cable : + materCable = cable['MATER'] + elasCable = self.reupere_structure(materCable,'ELAS') + ecroCable = self.reupere_structure(materCable,'ECRO_LINE') + dic_mater[nom_mater]['CABLE']={} + for car in ['E','NU']: + dic_mater[nom_mater]['CABLE'][car] = elasCable[car] + for car in ['SY']: + dic_mater[nom_mater]['CABLE'][car] = ecroCable[car] + for car in ['OMX','OMY','RX','RY','PREX','PREY'] : + dic_mater[nom_mater]['CABLE'][car] = cable[car] + Lnappes = self.setlist(self.reupere_structure(concept_mater,'NAPPE')) + if Lnappes : + for nappe in Lnappes : + dic_tmp = {} + materNappe = nappe['MATER'] + elasNappe = self.reupere_structure(materNappe,'ELAS') + ecroNappe = self.reupere_structure(materNappe,'ECRO_LINE') + for car in ['E','NU']: + dic_tmp[car] = elasNappe[car] + for car in ['SY']: + if ecroNappe : + dic_tmp[car] = ecroNappe[car] + else : + dic_tmp[car] = None + for car in ['OMX','OMY','RX','RY'] : + dic_tmp[car] = nappe[car] + for car in ['FS',] : + if nappe.has_key(car) : + dic_tmp[car] = nappe[car] + else : + dic_tmp[car] = None + dic_mater[nom_mater]['NAPPE'].append(dic_tmp) + Lliners = self.setlist(self.reupere_structure(concept_mater,'LINER')) + if Lliners : + for liner in Lliners : + dic_tmp = {} + materLiner = liner['MATER'] + elasLiner = self.reupere_structure(materLiner,'ELAS') + ecroLiner = self.reupere_structure(materLiner,'ECRO_LINE') + for car in ['E','NU']: + dic_tmp[car] = elasLiner[car] + for car in ['SY']: + dic_tmp[car] = ecroLiner[car] + for car in ['OML','RLR'] : + dic_tmp[car] = liner[car] + dic_mater[nom_mater]['LINER'].append(dic_tmp) + + + if debug: print 'MATER = %s \n type = %s \n dic = %s'%(nom_mater,typMat, dic_mater[nom_mater]) + dic_mater[nom_mater]['GROUP_MA'].extend(group_ma) + + # if gmaGLRC : + # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE') + # if debug: print 'ETAPES MAILLAGES' + # if debug: print dir(concept_maillage) + # if debug: print concept_maillage.executed + # if debug: print concept_maillage.etape + # if debug: print dir(concept_maillage.etape) + # if debug: print concept_maillage.etape.get_liste_etapes() + # if debug: print concept_maillage.etape.valeur + + + # Impression au format Europlexus + + for nom_mater in dic_mater.keys(): + epx[MODULE].append('*--MATERIAU %s' %nom_mater) + # mot cle indicant qu'il s'agit des caracteristiques lineaires du materiau + if typMat[nom_mater] == 'ELAS' : + dic_corresp = {'E':'YOUNG','NU':'NU','RHO':'RO'} + dic_corresp2 ={'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'} + epx[MODULE].append('LINE') + for car_aster in dic_corresp.keys(): + vale = dic_mater[nom_mater][car_aster] + car_epx = dic_corresp[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + for car_aster in dic_corresp2.keys(): + vale = dic_mater[nom_mater][car_aster] + car_epx = dic_corresp2[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + else : #GLRC + dic_corres1 = {'RHO':'RO','EPAIS':'H','E':'EB','NU':'NUB'} + dic_corresNapp = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY','FS':'FS'} + dic_corresPrec = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY'} + dic_corresLinr = {'E' : 'EA','SY':'FY','OML':'OMLR','NU':'NULR','RLR':'RLR'} + dic_corres2 = {'OMT' : 'OMT','EAT':'EAT','BT1':'BT1','BT2':'BT2','SYT' : 'FT','GAMMA':'GAMM','QP1':'QP1','QP2':'QP2','C1N1':'C1N1','C1N2':'C1N2','C1N3':'C1N3','C2N1':'C2N1','C2N2':'C2N2','C2N3':'C2N3','C1M1':'C1M1','C1M2':'C1M2','C1M3':'C1M3','C2M1':'C2M1','C2M2':'C2M2','C2M3':'C2M3','SYC':'FC'} + dic_corres2b = {'MP1X':'MP1X','MP2X':'MP2X','MP1Y':'MP1Y','MP2Y':'MP2Y',} + dic_corres3 = {'PREX' : 'PREX', 'PREY' : 'PREY'} + dic_corres4 = {'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'} + epx[MODULE].append('GLRC DAMA') + for car_aster in dic_corres1.keys(): + vale = dic_mater[nom_mater]['BETON'][car_aster] + car_epx = dic_corres1[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + nlit = len(dic_mater[nom_mater]['NAPPE'])+len(dic_mater[nom_mater]['LINER']) + if dic_mater[nom_mater].has_key('CABLE') : + nlit+=1 + if nlit : + epx[MODULE].append('%s %g' %('NLIT',nlit)) + for nappe in dic_mater[nom_mater]['NAPPE'] : + epx[MODULE].append('NAPP') + for car_aster in dic_corresNapp.keys(): + if nappe.has_key(car_aster) : + vale = nappe[car_aster] + car_epx = dic_corresNapp[car_aster] + if vale is not None: + epx[MODULE].append('%s %g' %(car_epx,vale)) + if dic_mater[nom_mater].has_key('CABLE') : + epx[MODULE].append('PREC') + for car_aster in dic_corresPrec.keys(): + vale = dic_mater[nom_mater]['CABLE'][car_aster] + car_epx = dic_corresPrec[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + for liner in dic_mater[nom_mater]['LINER'] : + epx[MODULE].append('LINR') + for car_aster in dic_corresLinr.keys(): + vale = liner[car_aster] + car_epx = dic_corresLinr[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + for car_aster in dic_corres2.keys(): + vale = dic_mater[nom_mater]['BETON'][car_aster] + car_epx = dic_corres2[car_aster] + if vale is not None : + if type(vale) == float : + epx[MODULE].append('%s %g' %(car_epx,vale)) + else : + epx[MODULE].append('%s %s' %(car_epx,vale)) + for car_aster in dic_corres2b.keys(): + vale = dic_mater[nom_mater]['BETON'][car_aster] + car_epx = dic_corres2b[car_aster] + if vale is not None : + if type(vale) == float : + epx[MODULE].append('%s %g' %(car_epx,vale)) + else : + epx[MODULE].append('%s %s' %(car_epx,vale)) + if dic_mater[nom_mater].has_key('CABLE') : + for car_aster in dic_corres3.keys(): + vale = dic_mater[nom_mater]['CABLE'][car_aster] + car_epx = dic_corres3[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + for car_aster in dic_corres4.keys(): + vale = dic_mater[nom_mater]['BETON'][car_aster] + car_epx = dic_corres4[car_aster] + if vale is not None : + epx[MODULE].append('%s %g' %(car_epx,vale)) + + # ajouter les group_ma qui ont ete affecte par ces caracteristiques + epx[MODULE].append(3*' '+'LECT') + for group in dic_mater[nom_mater]['GROUP_MA']: + epx[MODULE].append(7*' '+group) + epx[MODULE].append(3*' '+'TERM') + + + return epx + +#----------------------------------------------------------------------- + def export_EXCIT(self): + + epx = self.epx + + # CLe identifiant + MODULE = 'EXCIT' + + epx[MODULE] = ['*--DEFINITION DES CHARGEMENTS et DES CONDITIONS AUX LIMITES'] + + # Entete de la commande Europlexus courante + #epx[MODULE].append('CHARGEMENT') + + excit_list = self.setlist(self.EXCIT) + + # Traduction de ddl_impo + dic_ddl_impo = {'DX':1,'DY':2,'DZ':3,'DRZ':4,'DRY':5,'DRZ':6} + + # Initialisation des variables decrivant le chargement et les conditions de blocage + CHARGEMENT = [] + LIAISON = [] + + for excit in excit_list: + concept_charge = excit['CHARGE'] + pres_rep_list = self.reupere_structure(concept_charge,'PRES_REP') + ddl_impo_list = self.reupere_structure(concept_charge,'DDL_IMPO') + pres_rep_list = self.setlist(pres_rep_list) + ddl_impo_list = self.setlist(ddl_impo_list) + # PRES_REP + if pres_rep_list : + if len(CHARGEMENT) == 0 : CHARGEMENT = ['CHARGEMENT'] + fonction = self.get_motcle(excit,'FONC_MULT',code_mess='A') + if fonction is None: + UTMESS('F','PLEXUS_7') + (temps,valeurs) = fonction.Valeurs() + for pres_rep in pres_rep_list : + pression = pres_rep['PRES'] + group_ma = self.get_group_ma(pres_rep) + + CHARGEMENT.append(2*' ' + '1 FACTO 2') + CHARGEMENT.append(6*' ' +'PRESS COQU %g' %pression) + # ajouter les group_ma qui ont ete affecte par ces caracteristiques + CHARGEMENT.append(6*' '+'LECT') + for group in group_ma: + CHARGEMENT.append(10*' '+group) + CHARGEMENT.append(6*' '+'TERM') + # imprimer les valeurs de la table + CHARGEMENT.append(6*' ' +'TABLE %i' %len(temps)) + for ival in range(len(temps)): + CHARGEMENT.append(10*' ' +'%g %g' %(temps[ival],valeurs[ival])) + # DDL_IMPO + #if debug: print 'ddl_impo_list',ddl_impo_list + if ddl_impo_list : + #UTMESS('A','PLEXUS_8') + if len(LIAISON) == 0 : LIAISON = ['LIAISON'] + for ddl_impo in ddl_impo_list: + blocage = '' + for cle in dic_ddl_impo.keys() : + vale = self.get_motcle(ddl_impo,cle,code_mess='None') + if vale is not None: + if vale != 0 : UTMESS('F','PLEXUS_13') + else : + blocage += `dic_ddl_impo[cle]` + # recupere les entites geometriques + for entite in ['GROUP_MA','GROUP_NO'] : + group_ma = self.get_motcle(ddl_impo,entite,code_mess='None') + if group_ma is not None : + group_ma = self.setlist(group_ma);break + LIAISON.append(' '*2 + 'BLOQ %s' %blocage) + # ajouter les group_ma qui ont ete affecte par ces caracteristiques + LIAISON.append(6*' '+'LECT') + for group in group_ma: + LIAISON.append(10*' '+group) + LIAISON.append(6*' '+'TERM') + + if not ddl_impo_list and not pres_rep_list : + UTMESS('F','PLEXUS_9') + + # Transmettre les commandes a la liste global epx + for var in [CHARGEMENT,LIAISON] : + if len(var) > 0 : + epx[MODULE].append('\n') + for ligne in var : epx[MODULE].append(ligne) + + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def Correspondance_champ(self): + + # Dictionnaire de passage de champs Aster --> Europlexus + dic_champ = {'DEPL':'DEPLACEMENT','VITE':'VITESSE','ACCE':'ACCELERATION', + 'SIEF_ELGA':'CONT','EPSI_ELGA':'EPST','VARI_ELGA':'ECRO'} + + # Dictionnaire de passage de composantes Aster --> Europlexus + dic_cmp = {} + for cham in ['DEPL','VITE','ACCE'] : + dic_cmp[cham] = {'DX' : 1,'DY':2,'DZ':3,'DRX':4,'DRY':5,'DRZ':6} + + dic_cmp['SIEF_ELGA'] = {'SIXX':1,'SIYY':2,'SIZZ':3,'SIXY':4,'SIXZ':5,'SIYZ':6,'NXX':1,'NYY':2,'NXY':3,'MXX':4,'MYY':5,'MXY':6,'QX':7,'QY':8} + dic_cmp['VARI_ELGA'] = {} + for ii in range(1,25): + dic_cmp['VARI_ELGA']['V%i'%ii] = ii + + self.dic_champ = dic_champ + self.dic_cmp = dic_cmp + + +#----------------------------------------------------------------------- + def export_ECRITURE(self): + + epx = self.epx + + self.Correspondance_champ() + + # CLe identifiant + MODULE = 'ECRITURE' + + dcles_freq = {'FREQ':'PAS_NBRE', 'TFREQ':'PAS_INST'} + + def get_freq(fact): + for cle_freq in dcles_freq.keys(): +# AA vale_freq = self.get_motcle(fact,cle_freq,code_mess=None) + vale_freq = self.get_motcle(fact,dcles_freq[cle_freq],code_mess=None) + if vale_freq is not None : break + return cle_freq,vale_freq + + def get_freq2() : + if self.PAS_NBRE_COURBE : + return 'FREQ',self.PAS_NBRE_COURBE + elif self.PAS_INST_COURBE : + return 'TFREQ',self.PAS_INST_COURBE + else : + raise 'Erreur programmation' + + + def string2list(var) : + if types.TypeType(var) == types.StringType : var = (var,) + return var + + + epx[MODULE] = ['*--ECRITURES DES RESULTATS'] + epx[MODULE] = ['opti K2GP'] + # Entete de la commande Europlexus courante + epx[MODULE].append('ECRITURE') + + + # Traitement du mot-cle facteur OBSERVATION (EPX = LISTING) +# AA listing_fact = self.ECRITURE['LISTING'] + listing_fact = self.OBSERVATION + nom_cham = string2list(listing_fact['NOM_CHAM']) + + cle_freq_listing, vale_freq_listing = get_freq(listing_fact) +# AA cles_entite = ['POINTS','ELEMEMTS'] + dcles_entite = {'POINT':'GROUP_NO', 'ELEM':'GROUP_MA'} +# AA dcles_tout = {'POINTS':'TOUT_GROUP_NO', 'ELEMEMTS':'GROUP_MA'} + cles_entite = dcles_entite.keys() + + # Ecriture format Europlexus + + # Ecriture LISTING + st = 2*' ' + for cham_aster in nom_cham: + cham_epx = self.dic_champ[cham_aster] + st += '%s ' % cham_epx + st += ' %s %g' % (cle_freq_listing,vale_freq_listing) + st += ' NOPO NOEL' + epx[MODULE].append(st) + for cle in cles_entite: +# AA for cle in cles_entite : +# AA entite_geo = self.get_motcle(listing_fact ,cle, code_mess=None) +# AA entite_geo = string2list(entite_geo) + + entite_geo = string2list(listing_fact[dcles_entite[cle]]) + # if listing_fact['TOUT_%s' % dcles_entite[cle]] == 'OUI': epx[MODULE].append(2*' ' +'%s TOUS ' % cle) + # elif entite_geo is None: epx[MODULE].append(2*' ' +'NO%s' % cle) + # else: + # epx[MODULE].append(2*' ' +'%s LECT' %cle) + # for group in entite_geo : + # epx[MODULE].append(6*' '+group) + # epx[MODULE].append(2*' '+'TERM') + +# if entite_geo is None : +# epx[MODULE].append(2*' ' +'NO%s' %cle) +# elif entite_geo[0] == 'TOUS' : +# epx[MODULE].append(2*' ' +'%s TOUS ' %cle) +# else : +# epx[MODULE].append(2*' ' +'%s LECT' %cle) +# for group in entite_geo : +# epx[MODULE].append(6*' '+group) +# epx[MODULE].append(2*' '+'TERM') +# + + # Ecriture FICHIER ALICE UTILISE par le mot-cle facteur COURBE +# AA courbe_fact = self.ECRITURE['COURBE'] + courbe_fact = self.COURBE + if courbe_fact is not None : + + # dcourbe=[] + # for j in courbe_fact: + # dcourbe.append(j.cree_dict_valeurs(j.mc_liste)) + # for i in dcourbe[-1].keys(): + # if dcourbe[-1][i]==None : del dcourbe[-1][i] + + # if debug: print 'dcourbe=', dcourbe + + cle_freq, vale_freq = get_freq2() + fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT'] + epx[MODULE].append(2*' ' + "FICH ALIT 11 %s %g" %(cle_freq,vale_freq)) + + # Liste les noeuds a postraiter + lnoeuds=sets.Set([]) + lmailles=sets.Set([]) + for courbe in courbe_fact : + if courbe['GROUP_NO'] != None : + noeuds = courbe['GROUP_NO'] + if debug: print type(noeuds) + # liste de noeud ou un seul noeud ? + if type(noeuds) == tuple : + for el in noeuds : + lnoeuds.add(el) + else : + lnoeuds.add(noeuds) + elif courbe['GROUP_MA'] != None : + mailles = courbe['GROUP_MA'] + if debug: print type(mailles) + # liste de mailles ou une seule maille ? + if type(mailles ) == tuple : + for el in mailles : + lmailles.add(el) + else : + lmailles.add(mailles) + else : + raise 'Erreur ni noeud ni maille' + # sys.exit() + # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F') + # tables = self.setlist(tables) + + # icourbe = 0 + # for table in tables: + # icourbe += 1 + # noeud = table['NOEUD'] + # list_noeuds.append(noeud) + # Ecriture la liste des noeuds sous format epx + if lnoeuds : + epx[MODULE].append(4*' ' +'POINTS') + epx[MODULE].append(6*' ' +'LECT ') + for noeud in lnoeuds : + epx[MODULE].append(8*' '+noeud) + epx[MODULE].append(6*' '+'TERM') + if lmailles : + epx[MODULE].append(4*' ' +'ELEM') + epx[MODULE].append(6*' ' +'LECT ') + for maille in lmailles : + epx[MODULE].append(8*' '+maille) + epx[MODULE].append(6*' '+'TERM') + + + # Pas besoin d'elements + # epx[MODULE].append(4*' ' + 'NOELEMENTS') + + # Ecriture fichier MED representant les champs aux noeuds et aux points de gauss + # Traitement du mot-cle facteur ARCHIVAGE +# # Traitement du mot-cle facteur CHAMP +# champ_fact = self.ECRITURE['CHAMP'] + champ_fact = self.ARCHIVAGE + if champ_fact is not None : + cle_freq_champ,vale_freq_champ = get_freq(champ_fact) + epx[MODULE].append(2*' ' + 'FICHIER MED') + # chemin complet du fichier med + fichier_med = self.pwd + self.REPE + os.sep + self.nom_fichiers['MED'] + epx[MODULE].append(2*' ' + "'%s'" %fichier_med) + cle_freq,vale_freq = get_freq(champ_fact) + epx[MODULE].append(2*' ' + ' %s %g' %(cle_freq_champ,vale_freq_champ)) + + # groupes de mailles du modele + entite_geo={} + entite_geo['ELEM'] = [] + for model in ['DKT3','Q4GS'] : + if model in self.modelisations : + entite_geo['ELEM'].extend(self.dic_gma[model]) + entite_geo['POINT'] = [] + for model in ['DKT3','Q4GS','POUT'] : + if model in self.modelisations : + entite_geo['POINT'].extend(self.dic_gma[model]) + for cle in cles_entite : + epx[MODULE].append(2*' ' +'%s LECT' %cle) + for group in entite_geo[cle] : + epx[MODULE].append(6*' '+group) + epx[MODULE].append(2*' '+'TERM') + + # Une ligne de saut + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + + def export_POST_COURBE(self): + + # Suite de postraitement permettant d'ecrire des fichiers ASCII + # des grandeurs demandees + + # Tester si le mot_cle facteur COURBE a ete renseigne +# AA courbe_fact = self.ECRITURE['COURBE'] + courbe_fact = self.COURBE + if courbe_fact is None : return + + epx = self.epx + + # Cle identifiant + MODULE = 'POST_COURBE' + + # Ecriture fort Europlexus + # Entete de la commande courante + epx[MODULE] = ['SUITE\n'] + # epx[MODULE].append("'TITRE'") +# unite_alit = self.get_motcle(courbe_fact,'UNITE_ALIT',code_mess=None) +# if debug: print 'unite_alit=', unite_alit + if self.UNITE_COURBE: fichier_courbes = os.path.join(self.pwd, 'fort.%s' % str(self.UNITE_COURBE)) + else: fichier_courbes = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN'] + fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT'] + epx[MODULE].append("RESULTAT ALICE TEMPS 11") + epx[MODULE].append("OPNF FORMAT 17 '%s'" %fichier_courbes) + epx[MODULE].append("SORTIES GRAPHIQUES") + # epx[MODULE].append("PERFO '%s'"%fichier_courbes) + epx[MODULE].append("AXTEMPS 1. 'TEMPS(s)'") + + # recuperer le mot-cle facteur COURBE +# AA courbe_fact = self.ECRITURE['COURBE'] + courbe_fact = self.COURBE + # recuperer les mot_cle TABLE + # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F') + #tables = self.setlist(tables) + + # Dictionnaire decrivant les legendes des abscisses et ordodonnees des courbes imprimees + # et utilisee dans get_tables + self.legend_courbes = {} + entites_courbe = ['GROUP_NO','GROUP_MA'] + entite_EPX={'GROUP_NO' : 'NOEUD', 'GROUP_MA' : 'ELEM'} + icourbe = 0 + # for table in tables: + lnoeuds = [] + for table in courbe_fact : + for entite_type in entites_courbe : + try : entite = table[entite_type] + except : entite = None + if entite is not None : + cham_aster = table['NOM_CHAM'] + cmp_aster = table['NOM_CMP'] + cham_epx = self.dic_champ[cham_aster] + cmp_epx = self.dic_cmp[cham_aster][cmp_aster] + # ylabel = cham_aster + '_' + cmp_aster + ylabel = cmp_aster + if type(entite) is not tuple : entite = [entite,] + for el in entite : + icourbe+=1 + label = ylabel + '_%s'%el + if entite_type == 'MAILLE' : + label = label+'_%s'%table['NUM_GAUSS'] + st = "COURBE %i '%s' %s COMP %i "% (icourbe,label,cham_epx,cmp_epx) + if entite_type == 'MAILLE' : + st=st+"GAUSS %i "%table['NUM_GAUSS'] + st=st+"%s LECT %s TERM"%(entite_EPX[entite_type],el) + if debug: print 'st = %s'%st + epx[MODULE].append(st) + # epx[MODULE].append("LIST %i AXES 1. '%s'" % (icourbe,ylabel)) + st = "LIST %s AXES 1. '%s'" % (icourbe,label) + if debug: print 'st = %s'%st + epx[MODULE].append(st) + self.legend_courbes[icourbe] = ['TEMPS',label] + + + + # Une ligne de saut + epx[MODULE].append('\n') + +#----------------------------------------------------------------------- + def export_CALCUL(self): + + epx = self.epx + + # CLe identifiant + MODULE = 'CALCUL' + + # Entete de la commande Europlexus courante + epx[MODULE] = ['*--OPTION DE CALCUL'] + epx[MODULE].append('') + type_discr = self.CALCUL['TYPE_DISCRETISATION'] + + epx[MODULE].append('OPTION PAS %s' %type_discr) + + if type_discr == 'AUTO': + cstab = self.CALCUL['CSTAB'] + epx[MODULE].append(7*' ' + 'CSTAB %s' %cstab) + + listInterfaces = self.INTERFACES + listDomaines = self.DOMAINES + domaineInterfaces = {} + if listDomaines : + epx[MODULE].append('\n') + epx[MODULE].append('*--DEFINITION DES SOUS DOMAINES') + epx[MODULE].append('') + epx[MODULE].append('STRUCTURE %s'%len(listDomaines)) + for interface in listInterfaces : + Lgma1 = self.setlist(interface['GROUP_MA_1']) + Lgma2 = self.setlist(interface['GROUP_MA_2']) + idS1 = interface['IDENT_DOMAINE_1'] + idS2 = interface['IDENT_DOMAINE_2'] + if not domaineInterfaces.has_key(idS1) : + domaineInterfaces[idS1]= [] + if not domaineInterfaces.has_key(idS2) : + domaineInterfaces[idS2]= [] + domaineInterfaces[idS1].extend(Lgma1) + domaineInterfaces[idS2].extend(Lgma2) + else : + listDomaines = [] + for domaine in listDomaines : + Lgma = self.setlist(domaine['GROUP_MA']) + id = domaine['IDENTIFIANT'] + epx[MODULE].append(3*' '+'DOMA LECT') + for gma in Lgma : + epx[MODULE].append(12*' '+gma) + for gma in domaineInterfaces[id] : + epx[MODULE].append(12*' '+gma) + epx[MODULE].append(8*' '+'TERM') + epx[MODULE].append(8*' '+'IDENTIFIANT %s\n'%id) + + + if listInterfaces : + epx[MODULE].append('') + epx[MODULE].append('INTERFACE %s'%len(listInterfaces)) + else : + listInterfaces = [] + for interface in listInterfaces : + Lgma1 = self.setlist(interface['GROUP_MA_1']) + Lgma2 = self.setlist(interface['GROUP_MA_2']) + idS1 = interface['IDENT_DOMAINE_1'] + idS2 = interface['IDENT_DOMAINE_2'] + tole = interface['TOLE'] + epx[MODULE].append(3*' '+'MORTAR TOLE %g'%tole) + epx[MODULE].append(7*' '+'DOMA %s LECT'%idS1) + for gma in Lgma1 : + epx[MODULE].append(13*' '+gma) + epx[MODULE].append(10*' '+'TERM') + epx[MODULE].append(7*' '+'DOMA %s LECT'%idS2) + for gma in Lgma2 : + epx[MODULE].append(13*' '+gma) + epx[MODULE].append(10*' '+'TERM') + + epx[MODULE].append('\n') + epx[MODULE].append('*--LANCEMENT DE CALCUL') + epx[MODULE].append('') + calcul = 'CALCUL' +# AAA cles = ['INST_INIT','PASFIX','INST_FIN','DTMAX'] + cles = ['INST_INIT','PASFIX','INST_FIN'] + dcles = {'INST_INIT':'TINI', 'PASFIX':'PASFIX', 'INST_FIN':'TFIN'} + for cle in dcles.keys(): + try : calcul += ' %s %g' %(dcles[cle], self.CALCUL[cle]) + except : pass + # Doit etre mis en entier + try : calcul += ' %s %d' %('NMAX',self.CALCUL['NMAX']) + except : pass + epx[MODULE].append(calcul) + epx[MODULE].append('\n') + #epx[MODULE].append('FIN') + + +#----------------------------------------------------------------------- + def ecrire_fichier(self,): + + fichier = self.REPE + os.sep + self.nom_fichiers['COMMANDE'] + + # ordre des modules de definition du modele EPX + modules = ['DEBUT','MAILLAGE','DIME','MODELE','CARA_ELEM','FONC_PARASOL','CHAM_MATER','RIGI_PARASOL','EXCIT','ECRITURE','CALCUL','POST_COURBE'] + + #les modules MODELE et RIGI_PARASOL doivent etre executes avant MAILLAGE + # car le maillage peut etre modifie dans ces modules + modules_exe = [] + modules_exe.extend(modules) + modules_exe.remove('MAILLAGE') + modules_exe.append('MAILLAGE') + + # Excecution des differentes modules + for module in modules_exe: + fct = 'export_%s' %module + if hasattr(self,fct) : + eval('self.'+fct+'()') + else : + print 'module %s pas encore developpe' %fct + + # Ecriture du fichier texte contenant toutes les commandes Europlexus + fd = open(fichier,'w') + for module in modules : + if self.epx.has_key(module) : + for ll in self.epx[module]: + if debug: print 'EPX : %s'%ll + fd.write('%s\n'%ll) + # Fin du fichier de commandes epx + fd.write('FIN') + fd.close() + +#----------------------------------------------------------------------- + def get_table(self,icourbe=1,fichier='auto') : + + global table + + if not hasattr(self,'courbes'): + if fichier == 'auto' : fichier = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN'] + if not os.path.isfile(fichier) : return + self.courbes = self.lire_pun(fichier=fichier) + + if not os.path.isfile(fichier) : return + if debug: print self.courbes,type(self.courbes) + nc = 0 + para_ordonnee = [] + dico = [] + for icourbe in self.courbes : + valeurs = self.courbes[icourbe] + if debug: print 'icourbe = %s ; valeurs = %s'%(icourbe, valeurs) + if nc == 0 : + para_abscisse = self.legend_courbes[icourbe][0] + vale_abscisse = valeurs[0,:].tolist() + assert (len(para_abscisse)<17) + dico.append({'TYPE_K':'K16','LISTE_R' : vale_abscisse , 'PARA' : para_abscisse}) + para_ordonnee = self.legend_courbes[icourbe][1] + vale_ordonnee = valeurs[1,:].tolist() + assert (len(para_ordonnee)<17) + dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee}) + nc=1 + else : + if ((self.legend_courbes[icourbe][0] == para_abscisse) and (vale_abscisse == valeurs[0,:].tolist())) : + para_ordonnee = self.legend_courbes[icourbe][1] + vale_ordonnee = valeurs[1,:].tolist() + assert (len(para_ordonnee)<17) + dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee}) + else : + raise 'Table non compatible' + + table = CREA_TABLE( LISTE =dico + ); + + if 0 : + unite = self.get_unite_libre() + unite = 90 + DEFI_FICHIER(UNITE=unite,ACTION='ASSOCIER'); + + IMPR_TABLE(UNITE = unite, + FORMAT = 'XMGRACE', + TABLE = table, + LEGENDE_X = para_abscisse, + LEGENDE_Y = para_ordonnee, + LEGENDE = 'test' + ); + + os.system('xmgrace fort.%i' %unite) + + DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); + + +#----------------------------------------------------------------------- + def get_resu(self,fichier_med='auto'): + + # Rendre global le resu pour qu'il soit accepte dans self.DeclareOut + global resu + + if fichier_med == 'auto' : fichier_med = self.REPE + os.sep + self.nom_fichiers['MED'] + + if debug: print fichier_med + if not os.path.isfile(fichier_med) : + print "Pas de fichier MED !" + return + + # Format med des champs depl, vite et acce + format_med =[_F(NOM_CHAM_MED='CHAMP___DEPLACEMENT___001', + NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'), + NOM_CMP_MED=('UX','UY','UZ','RX','RY','RZ'), + NOM_CHAM ='DEPL' ), + _F(NOM_CHAM_MED='CHAMP___VITESSE___001', + NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'), + NOM_CMP_MED=('VX','VY','VZ','RX','RY','RZ'), + NOM_CHAM ='VITE' ), + _F(NOM_CHAM_MED='CHAMP___ACCELERATION___001', + NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'), + NOM_CMP_MED=('GX','GY','GZ','RX','RY','RZ'), + NOM_CHAM ='ACCE' ), + ] + + # Dicionnaire permettant de faire la correspondance des champs aux pts de gauss entre le med de europlexus et aster + dic_cmp_gauss = {} + + dic_cmp_gauss['CONTRAINTE'] = {'DKT3': {'NOM_CMP' : ('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'), + 'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6',),}, + 'Q4GS': {'NOM_CMP' : ('NXX','NYY','NXY','MXX','MYY','MXY','QX','QY'), + 'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6','SIG7','SIG8'),}, + 'POUT' : {} + + } + + dic_cmp_gauss['DEFORMATION'] = {'DKT3': {'NOM_CMP' : ('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'), + 'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6',),}, + 'Q4GS': {'NOM_CMP' : ('EXX','EYY','EXY','KXX','KYY','KXY','GAX','GAY'), + 'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6','EPS7','EPS8'),}, + 'POUT' : {} + + } + + dic_cmp_gauss['ECROUISSAGE'] = {'DKT3': {'NOM_CMP' : ('V1','V2'), + 'NOM_CMP_MED' : ('VAR8','VAR9'),}, + 'Q4GS' : {'NOM_CMP' : ('V1','V2'), + 'NOM_CMP_MED' : ('VAR8','VAR9'),}, + 'POUT' : {} + + } + + # Dictionnaire permettant de traduire le champ epx en med au nom asscie dans aster +# AA epx2aster = {'CONTRAINTE':'SIEF_ELGA','ECROUISSAGE':'VARI_ELGA'} + epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA_DEPL','ECROUISSAGE':'VARI_ELGA'} + +# AA : desactive pour le moment +# # Enrichir la liste format_med par les champs aux pts de gauss +# imode = 0 +# if debug: print 'self.modelisations',self.modelisations +# for modelisation in self.modelisations : +# #if modelisation in ['Q4GS','DKT3'] : +# imode += 1 +# numero = string.replace('%3.i' %imode,' ','0') +# for champ in dic_cmp_gauss.keys(): +# if len(dic_cmp_gauss[champ][modelisation]) > 0 : +# nom_cham_med = 'CHAMP___'+ champ + (13-len(champ))*'_' + numero +# nom_cham = epx2aster[champ] +# nom_cmp = dic_cmp_gauss[champ][modelisation]['NOM_CMP'] +# nom_cmp_med = dic_cmp_gauss[champ][modelisation]['NOM_CMP_MED'] +# # ajouer a la list format_med +# format_med.append(_F(NOM_CHAM_MED=nom_cham_med,NOM_CMP=nom_cmp, +# NOM_CMP_MED=nom_cmp_med,NOM_CHAM=nom_cham) +# ) + + # Lire le fichier med avec les options choisies dans la liste format_med + unite = self.get_unite_libre() + DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); + fort = 'fort.%i' %unite + if os.path.isfile(fort) : os.remove(fort) + + os.symlink(fichier_med,fort) + + # Regeneration des mots-cles EXCIT passés en argument de la macro + dExcit=[] + for j in self.EXCIT : + dExcit.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dExcit[-1].keys(): + if dExcit[-1][i]==None : del dExcit[-1][i] + resu = LIRE_RESU(TYPE_RESU='EVOL_NOLI', +# VERI_ELGA='NON', + FORMAT='MED', + MODELE=self.NEW_MODELE, + FORMAT_MED=format_med, + UNITE=unite, + CHAM_MATER=self.CHAM_MATER, + CARA_ELEM=self.CARA_ELEM, + TOUT_ORDRE='OUI', + EXCIT=dExcit, + INFO=self.INFO, + ); + + __EPN = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_R', + OPERATION = 'AFFE', + MODELE = self.NEW_MODELE, + PROL_ZERO = 'OUI', + AFFE = self.listEpais, + ) + __EPN2 = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_R', + OPERATION = 'AFFE', + MODELE = self.NEW_MODELE, + PROL_ZERO = 'OUI', + AFFE = self.listEpais2, + ) + __UNN = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_R', + OPERATION = 'AFFE', + MODELE = self.NEW_MODELE, + PROL_ZERO = 'OUI', + AFFE = _F(VALE=(1.,1.), TOUT='OUI', NOM_CMP=('X21','X22')), + ) + __FONC1 = FORMULE(VALE='X1*X21',NOM_PARA=('X1','X21')) + __FONC2 = FORMULE(VALE='X2*X21',NOM_PARA=('X2','X21')) + __FONC3 = FORMULE(VALE='X3*X21',NOM_PARA=('X3','X21')) + __FONC4 = FORMULE(VALE='X4*X22',NOM_PARA=('X4','X22')) + __FONC5 = FORMULE(VALE='X5*X22',NOM_PARA=('X5','X22')) + __FONC6 = FORMULE(VALE='X6*X22',NOM_PARA=('X6','X22')) + __FONC7 = FORMULE(VALE='X7*X21',NOM_PARA=('X7','X21')) + __FONC8 = FORMULE(VALE='X8*X21',NOM_PARA=('X8','X21')) + __FONC11 = FORMULE(VALE='X11*X21',NOM_PARA=('X11','X21')) + __FONC12 = FORMULE(VALE='X12*X21',NOM_PARA=('X12','X21')) + __FONC13 = FORMULE(VALE='X13*X21',NOM_PARA=('X13','X21')) + __FONC14 = FORMULE(VALE='X14*X22',NOM_PARA=('X14','X22')) + __FONC15 = FORMULE(VALE='X15*X22',NOM_PARA=('X15','X22')) + __FONC16 = FORMULE(VALE='X16*X22',NOM_PARA=('X16','X22')) + __FONC17 = FORMULE(VALE='X17*X21',NOM_PARA=('X17','X21')) + __FONC18 = FORMULE(VALE='X18*X21',NOM_PARA=('X18','X21')) + + __FONCC = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_F', + OPERATION = 'AFFE', + MODELE = self.NEW_MODELE, + PROL_ZERO = 'OUI', + AFFE = _F( + TOUT = 'OUI', + NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8','X11','X12','X13','X14','X15','X16','X17','X18'), + VALE_F = (__FONC1,__FONC2,__FONC3,__FONC4,__FONC5,__FONC6,__FONC7,__FONC8,__FONC11,__FONC12,__FONC13, + __FONC14,__FONC15,__FONC16,__FONC17,__FONC18)), + ) + __FONCC2 = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_F', + OPERATION = 'AFFE', + MODELE = self.NEW_MODELE, + PROL_ZERO = 'OUI', + AFFE = _F( + TOUT = 'OUI', + NOM_CMP = ('X1','X2'), + VALE_F = (__FONC1,__FONC2)), + ) + listEffg = [] + i=0 + listType=[] + __SIG11 = [None]*10 + __SIG21 = [None]*10 + + # Pour masquer certaines alarmes + from Utilitai.Utmess import MasquerAlarme, RetablirAlarme + MasquerAlarme('MED_83') + MasquerAlarme('MED_98') + + while 1: + # index=1 + # pas = self.ARCHIVAGE['PAS_NBRE'] + # dicDetr=[] + # if 'Q4GS' in self.modelisations : + err = 0 + try : + __SIG11[i] = LIRE_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_SIEF_R', + UNITE = 99, + NUME_PT = 0, + MODELE = self.NEW_MODELE, + MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + PROL_ZERO = 'OUI', + NOM_MED = 'CHAMP___CONTRAINTE___00%d'%(i+1), + NOM_CMP = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'], + NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED']) + # dicDetr.append({'NOM' : __SIG11}) + DETRUIRE(CONCEPT=_F(NOM = __SIG11[i]), INFO=1) + listType.append('Q4GS') + # index=2 + except : + err+=1 + try : + __SIG21[i] = LIRE_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_SIEF_R', + UNITE = 99, + NUME_PT = 0, + MODELE = self.NEW_MODELE, + MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + PROL_ZERO = 'OUI', + NOM_MED = 'CHAMP___CONTRAINTE___00%d'%(i+1), + NOM_CMP = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'], + NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']), + DETRUIRE(CONCEPT=_F(NOM = __SIG21[i]), INFO=1) + if len(listType) 1 : + # break + # DETRUIRE(CONCEPT=dicDetr) + # i+=1 + + # Pour la gestion des alarmes + RetablirAlarme('MED_83') + RetablirAlarme('MED_98') + + + nbChamp = i + itot=len(resu.LIST_PARA()['INST']) + __EFFG=[None]*itot + # __EPSG=[None]*itot + __ECRG=[None]*itot + __SIG1 = [None]*nbChamp + __SIG2 = [None]*nbChamp + for i in xrange(itot) : + dicAffe=[] + dicAffe2=[] + dicAffe3=[] + index=1 + pas = self.ARCHIVAGE['PAS_NBRE'] + dicAsse = [{'TOUT' : 'OUI', 'CHAM_GD' : __EPN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}] + dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPN2, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.}) + dicAsse2 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}] + dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.}) + dicAsse3 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}] + dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.}) + dicDetr=[] + # if 'Q4GS' in self.modelisations : + for j in xrange(nbChamp) : + if listType[j] == 'Q4GS' : + __SIG1[j] = LIRE_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_SIEF_R', + UNITE = 99, + NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], + MODELE = self.NEW_MODELE, + MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + PROL_ZERO = 'OUI', + NOM_MED = 'CHAMP___CONTRAINTE___00%d'%(j+1), + NOM_CMP = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'], + NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED'], + ) + # __EPS1 = LIRE_CHAMP( + # INFO = self.INFO, + # TYPE_CHAM = 'ELGA_EPSI_R', + # UNITE = 99, + # NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], + # MODELE = self.NEW_MODELE, + # MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + # PROL_ZERO = 'OUI', + # NOM_MED = 'CHAMP___DEFORM_TOT___001', + # NOM_CMP = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP'], + # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP_MED']) +# __ECR1 = LIRE_CHAMP( +# INFO = self.INFO, +# TYPE_CHAM = 'ELGA_VARI_R', +# UNITE = 99, +# NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], +# MODELE = self.NEW_MODELE, +# MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), +# PROL_ZERO = 'OUI', +# NOM_MED = 'CHAMP___ECROUISSAGE__001', +# NOM_CMP = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'], +# NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED']) + dicDetr.append({'NOM' : __SIG1[j]}) + dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG1[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']), + 'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.}) + # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS1, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']), + # 'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.}) +# dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR1, 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP']), +# 'NOM_CMP_RESU' : ('X1','X2'), 'CUMUL' : 'OUI','COEF_R':1.}) + else : + __SIG2[j] = LIRE_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_SIEF_R', + UNITE = 99, + NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], + MODELE = self.NEW_MODELE, + MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + PROL_ZERO = 'OUI', + NOM_MED = 'CHAMP___CONTRAINTE___00%d'%(j+1), + NOM_CMP = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'], + NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED'], + ) + # __EPS2 = LIRE_CHAMP( + # INFO = self.INFO, + # TYPE_CHAM = 'ELGA_EPSI_R', + # UNITE = 99, + # NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], + # MODELE = self.NEW_MODELE, + # MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), + # PROL_ZERO = 'OUI', + # NOM_MED = 'CHAMP___DEFORM_TOT___00%d'%index, + # NOM_CMP = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP'], + # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP_MED']), +# __ECR2 = LIRE_CHAMP( +# INFO = self.INFO, +# TYPE_CHAM = 'ELGA_VARI_R', +# UNITE = 99, +# NUME_PT = resu.LIST_PARA()['NUME_ORDRE'][i], +# MODELE = self.NEW_MODELE, +# MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'), +# PROL_ZERO = 'OUI', +# NOM_MED = 'CHAMP___ECROUISSAGE__00%d'%index, +# NOM_CMP = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'], +# NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED']) + dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG2[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP']), + 'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.}) + # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS2, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP']), + # 'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.}) +# dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR2, 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP']), +# 'NOM_CMP_RESU' : ('X11','X12'), 'CUMUL' : 'OUI','COEF_R':1.}) + dicDetr.append({'NOM' : __SIG2[j]}) + # dicDetr.append({'NOM' : __EPS2}) +# dicDetr.append({'NOM' : __ECR2}) + # dicDetr.append({'NOM' : __EPS1}) +# dicDetr.append({'NOM' : __ECR1}) + # if 'DKT3' in self.modelisations: + + __SIGN = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_R', + OPERATION = 'ASSE', + PROL_ZERO = 'OUI', + MODELE = self.NEW_MODELE, + ASSE = dicAsse, + ) + # __EPSN = CREA_CHAMP( + # INFO = self.INFO, + # TYPE_CHAM = 'ELGA_NEUT_R', + # OPERATION = 'ASSE', + # PROL_ZERO = 'OUI', + # MODELE = self.NEW_MODELE, + # ASSE = dicAsse2) +# __ECRN = CREA_CHAMP( +# INFO = self.INFO, +# TYPE_CHAM = 'ELGA_NEUT_R', +# OPERATION = 'ASSE', +# PROL_ZERO = 'OUI', +# MODELE = self.NEW_MODELE, +# ASSE = dicAsse3) + dicDetr.append({'NOM' : __SIGN}) + # dicDetr.append({'NOM' : __EPSN}) +# dicDetr.append({'NOM' : __ECRN}) + __EFFGN = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_NEUT_R', + OPERATION = 'EVAL', + CHAM_F = __FONCC, + CHAM_PARA = (__SIGN), + ) + # __EPSGN = CREA_CHAMP( + # INFO = self.INFO, + # TYPE_CHAM = 'ELGA_NEUT_R', + # OPERATION = 'EVAL', + # CHAM_F = __FONCC, + # CHAM_PARA = (__EPSN)) +# __ECRGN = CREA_CHAMP( +# INFO = self.INFO, +# TYPE_CHAM = 'ELGA_NEUT_R', +# OPERATION = 'EVAL', +# CHAM_F = __FONCC2, +# CHAM_PARA = (__ECRN)) + dicDetr.append({'NOM' : __EFFGN}) + # dicDetr.append({'NOM' : __EPSGN}) +# dicDetr.append({'NOM' : __ECRGN}) + __EFFG[i] = CREA_CHAMP( + INFO = self.INFO, + TYPE_CHAM = 'ELGA_SIEF_R', + OPERATION = 'ASSE', + PROL_ZERO = 'OUI', + MODELE = self.NEW_MODELE, + ASSE = _F( + TOUT = 'OUI', + CHAM_GD = __EFFGN, + NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'), + NOM_CMP_RESU = tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']+dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'])), + ) + # __EPSG[i] = CREA_CHAMP( + # INFO = self.INFO, + # TYPE_CHAM = 'ELGA_EPSI_R', + # OPERATION = 'ASSE', + # PROL_ZERO = 'OUI', + # MODELE = self.NEW_MODELE, + # ASSE = _F( + # TOUT = 'OUI', + # CHAM_GD = __EPSGN, + # NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'), + # NOM_CMP_RESU = tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']+dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP']))) +# __ECRG[i] = CREA_CHAMP( +# INFO = self.INFO, +# TYPE_CHAM = 'ELGA_VARI_R', +# OPERATION = 'ASSE', +# PROL_ZERO = 'OUI', +# MODELE = self.NEW_MODELE, +# ASSE = _F( +# TOUT = 'OUI', +# CHAM_GD = __ECRGN, +# NOM_CMP = ('X1','X2'), +# NOM_CMP_RESU = tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP']))) + dicAffe.append({'CHAM_GD' : __EFFG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]}) + # dicAffe2.append({'CHAM_GD' : __EPSG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]}) +# dicAffe3.append({'CHAM_GD' : __ECRG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]}) + DETRUIRE(CONCEPT=dicDetr, INFO=1) + resu = CREA_RESU(reuse=resu, + OPERATION = 'AFFE', + TYPE_RESU = 'EVOL_NOLI', + NOM_CHAM = 'SIEF_ELGA', + AFFE = dicAffe, + ) + # resu = CREA_RESU(reuse=resu, + # OPERATION = 'AFFE', + # TYPE_RESU = 'EVOL_NOLI', + # NOM_CHAM = 'EPSI_ELGA_DEPL', + # AFFE = dicAffe2) + resu = CREA_RESU(reuse=resu, + OPERATION = 'AFFE', + TYPE_RESU = 'EVOL_NOLI', + NOM_CHAM = 'VARI_ELGA', + AFFE = dicAffe3, + ) + + DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); + + os.remove(fort) + +#----------------------------------------------------------------------- + def lancer_calcul(self,fichier_med='auto'): + + fichier_epx = self.nom_fichiers['COMMANDE'] + EXEC_LOGICIEL(LOGICIEL='cd %s ; %s %s ; iret=$? ; cd %s ; exit $iret' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd), + INFO=2) + + +#------------------------------------------------------------------------ +#----------------------------- FIN class EUROPLEXUS --------------------- +#------------------------------------------------------------------------ + + +#------------------------------------------------------------------------ +#----------------------------- class POUTRE ----------------------------- +#------------------------------------------------------------------------ + +class POUTRE: + def __init__(self,MAILLAGE,CARA_ELEM): + + # recuperer les infos du maillage sous format python + self.MApyt = MAIL_PY() + self.MApyt.FromAster(MAILLAGE) + self.CARA_ELEM = CARA_ELEM + # un dictionnaire stockant tous orientations definis dans AFF_CARA_ELEM + self.dic_gma = self.orientation_cara_elem() + +#------------------------------------------------------------------------ + def getvecteurs(self,groupes_poutres,verif='non'): + vecteurs = {} + ig = 0 + message = 0 + for gr in groupes_poutres : + ig += 1 + if not self.dic_gma.has_key(gr): self.dic_gma[gr] = {'ANGL_VRIL':0.0} + vecteurs[gr] = self.get_vecty_group_ma(gr) + if verif == 'oui': + if ig > 1 : + if not vecteurs_egaux(vecteurs[gr],vect_old) : message = 1 + vect_old = vecteurs[gr] + + if message : UTMESS('F','PLEXUS_10',valk=groupes_poutres) + + return vecteurs + +#------------------------------------------------------------------------ + def orientation_cara_elem(self,): + + dic_gma = {} + etapes = self.CARA_ELEM.etape.valeur + + if not etapes.has_key('ORIENTATION') : return dic_gma + + orientation = etapes['ORIENTATION'] + try : + test = orientation [0] + except : + orientation = [orientation] + + for ll in orientation : + cara = ll['CARA'] + if cara in ['ANGL_VRIL','ANGL_NAUT','VECT_Y'] : + if ll.has_key('GROUP_MA') : + group_ma = ll['GROUP_MA'] + if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,) + a = ll['VALE'] + for gr in group_ma: + if not dic_gma.has_key(gr): dic_gma[gr] = {} + dic_gma[gr][cara] = a + + for gr in dic_gma.keys() : + if not dic_gma[gr].has_key('VECT_Y'): + if not dic_gma[gr].has_key('ANGL_VRIL') : dic_gma[gr]['ANGL_VRIL'] = 0.0 + if dic_gma[gr].has_key('ANGL_NAUT'): + if len(dic_gma[gr]['ANGL_NAUT']) == 2 : + dic_gma[gr]['ANGL_NAUT'] = list(dic_gma[gr]['ANGL_NAUT']) + [dic_gma[gr]['ANGL_VRIL']] + + return(dic_gma) + +#------------------------------------------------------------------------ + def get_vecty_group_ma(self,group_ma): + + #if debug: print '*'*10 + #if debug: print 'Test de group_ma',group_ma + #if debug: print '*'*10 + + message = 0 + + if self.dic_gma[group_ma].has_key('VECT_Y') : return self.dic_gma[group_ma]['VECT_Y'] + + if not self.dic_gma[group_ma].has_key('ANGL_NAUT'):calcul_angle = 1 + else: calcul_angle = 0 + + mailles = self.MApyt.gma[string.rstrip(group_ma)] + + for imaille in range(len(mailles)): + maille = mailles[imaille] + if calcul_angle: + alpha,beta = self.calcul_angles_naut(maille) + angl = [alpha,beta,self.dic_gma[group_ma]['ANGL_VRIL']] + else: + angl = self.dic_gma[group_ma]['ANGL_NAUT'] + + vect_y = self.angle2vecty(angl) + if imaille > 1 : + if not vecteurs_egaux(vect_y0,vect_y) : message = 1 + vect_y0 = vect_y + + self.dic_gma[group_ma]['VECT_Y'] = vect_y + + if message : + #if debug: print 'group_ma',group_ma + UTMESS('F','PLEXUS_11',valk=group_ma) + + return vect_y + +#------------------------------------------------------------------------ + def angle2vecty(self,angl): + #transformer en rd + for iangl in range(len(angl)): + angl[iangl] = N.pi*angl[iangl]/180. + + cosa = math.cos( angl[0] ) + sina = math.sin( angl[0] ) + cosb = math.cos( angl[1] ) + sinb = math.sin( angl[1] ) + cosg = math.cos( angl[2] ) + sing = math.sin( angl[2] ) + vect = [ sing*sinb*cosa - cosg*sina , cosg*cosa + sing*sinb*sina , sing*cosb ] + for ii in range(len(vect)): + if abs(vect[ii]) <= tst : vect[ii] = 0.0 + vect = N.array(vect) + vect = vect/norme(vect) + return vect + +#------------------------------------------------------------------------ + def get_coor_nodes_maille(self,maille): + node1,node2 = self.MApyt.co[maille] + coor1 = self.MApyt.cn[node1] + coor2 = self.MApyt.cn[node2] + return [coor1,coor2] + +#------------------------------------------------------------------------ + def calcul_angles_naut(self,maille): + + # Angles directeurs d'une poutre (nautiques) + + a,b = self.get_coor_nodes_maille(maille) + + gx = [ b[0]-a[0] , b[1]-a[1] , b[2]-a[2] ] + + if( (abs(gx[1]) < tst) and (abs(gx[0]) <= tst) ): + alpha = 0.0 + else: + alpha = math.atan2(gx[1],gx[0]) + + p = math.sqrt( gx[0]*gx[0] + gx[1]*gx[1] ) + if( (abs(gx[2]) < tst ) and (abs(p) <=tst) ): + beta = 0.0 + else: + beta = -math.atan2(gx[2],p) + + # alpha et Beta en degre + alpha = alpha*180./math.pi + beta = beta*180./math.pi + + return alpha,beta + +#------------------------------------------------------------------------ +#----------------------------- FIN class POUTRE ------------------------- +#------------------------------------------------------------------------ + + +#------------------------------------------------------------------------ +#----------------------------- class DKT -------------------------------- +#------------------------------------------------------------------------ + +class DKT: + + def __init__(self,MAILLAGE): + + self.MAILLAGE = MAILLAGE + # recuperer les infos du maillage sous format python + self.MApyt = MAIL_PY() + self.MApyt.FromAster(MAILLAGE) + + def aster2epx(self,groups): + + # initialisations du dic contenant les mailles de tria3 et quad4 + dic_groups = {} + for cle in ['TRIA3','QUAD4']: + dic_groups[cle] = [] + # placer les mailles dans le champ associe + for gr in groups: + mailles = self.MApyt.gma[string.rstrip(gr)] + for maille in mailles: + code_maille = self.MApyt.tm[maille] + type_maille = self.MApyt.nom[code_maille] + maille_initiale = string.rstrip(self.MApyt.correspondance_mailles[maille]) + if not maille_initiale in dic_groups[type_maille] : + dic_groups[type_maille].append(maille_initiale) + + # creer le mot-cle facteur permettant de creer les groupes de mailles associes au TRIA3 et QUAD4 + crea_group_ma = [] + # dictionnair contenant les noms des groups qui vont etre creer au besoin + nom_groups = {} + for cle in dic_groups.keys() : + if len(dic_groups[cle]) > 0 : + crea_group_ma.append({'MAILLE':dic_groups[cle],'NOM':cle}) + nom_groups[cle] = [cle] + else: + nom_groups[cle] = [] + # ce n'est pas necessaire de creer les group_ma si on n'a pas de quad4 + if len(dic_groups['QUAD4']) >0: + + #global DEFI_GROUP + + DEFI_GROUP(reuse = self.MAILLAGE, + MAILLAGE = self.MAILLAGE, + CREA_GROUP_MA = crea_group_ma, + ); + + else : + # on affecte au TRIA les groupes deja fournis en argument + nom_groups['TRIA3'] = groups + + return nom_groups + +#------------------------------------------------------------------------ +#----------------------------- FIN class DKT ---------------------------- +#------------------------------------------------------------------------ diff --git a/Aster/Cata/cataSTA9/Macro/calc_modal_ops.py b/Aster/Cata/cataSTA9/Macro/calc_modal_ops.py new file mode 100644 index 00000000..c462a3b6 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/calc_modal_ops.py @@ -0,0 +1,162 @@ +#@ MODIF calc_modal_ops Macro DATE 14/10/2008 AUTEUR NISTOR I.NISTOR + +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 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 -*- + + +def calc_modal_ops(self,MODELE,CHAM_MATER,CARA_ELEM,AMORTISEMENT, + SOLVEUR,CHARGE,INST,METHODE,CALC_FREQ, MODE_RIGIDE, + VERI_MODE,INFO,**args): + """ + Ecriture de la macro CALC_MODAL + """ + from Accas import _F + ier=0 + from Utilitai.Utmess import UTMESS + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + CALC_MATR_ELEM=self.get_cmd('CALC_MATR_ELEM') + NUME_DDL =self.get_cmd('NUME_DDL') + ASSE_MATRICE =self.get_cmd('ASSE_MATRICE') + MODE_ITER_SIMULT =self.get_cmd('MODE_ITER_SIMULT') + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + + # on defini la liste des mots cle pour les appels aux CALC_MATR_ELEM + motsclece={} + if CHARGE != None: motsclece['CHARGE'] =CHARGE + if CHAM_MATER != None: motsclece['CHAM_MATER'] =CHAM_MATER + if CARA_ELEM != None: motsclece['CARA_ELEM'] =CARA_ELEM + if INST != None: motsclece['INST'] =INST + + #c'est avec le mot cle AMORTISEMENT qu'on decide si on calcule la matrice C + # d'amortisement + + + _a=CALC_MATR_ELEM(MODELE=MODELE, OPTION='RIGI_MECA', **motsclece) + _b=CALC_MATR_ELEM(MODELE=MODELE, OPTION='MASS_MECA', **motsclece) + if AMORTISEMENT=='OUI': + _c=CALC_MATR_ELEM(MODELE=MODELE, OPTION='AMOR_MECA', + RIGI_MECA=_a, MASS_MECA=_b,**motsclece) + + #on produit en local le concept NUME_DDL, il n'est pas visible pour l'utilisateur + + # Les mots cles simples sous SOLVEUR sont par defaut MULT_FRONT/METIS + methode=SOLVEUR['METHODE'] + renum=SOLVEUR['RENUM'] + + _num=NUME_DDL(MATR_RIGI=_a,METHODE=methode,RENUM=renum,INFO=INFO) + + #assemblages des matrices + _rigas=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=_num) + _masas=ASSE_MATRICE(MATR_ELEM=_b,NUME_DDL=_num) + if AMORTISEMENT=='OUI': + _amoras=ASSE_MATRICE(MATR_ELEM=_c,NUME_DDL=_num) + + #lancement du calcul des modes propres + # on defini la liste des mots cle pour l'appel au MODE_ITER_SIMULT + + motscit={} + motscfa={} + + if METHODE=='TRI_DIAG': + if args.has_key('NMAX_ITER_ORTHO'): + motscit['NMAX_ITER_ORTHO'] =args['NMAX_ITER_ORTHO'] + if args.has_key('PREC_ORTHO'): + motscit['PREC_ORTHO'] =args['PREC_ORTHO'] + if args.has_key('PREC_LANCZOS'): + motscit['PREC_LANCZOS'] =args['PREC_LANCZOS'] + if args.has_key('MAX_ITER_QR'): + motscit['NMAX_ITER_QR'] =args['NMAX_ITER_QR'] + elif METHODE=='JACOBI': + if args.has_key('NMAX_ITER_BATHE'): + motscit['NMAX_ITER_BATHE'] =args['NMAX_ITER_BATHE'] + if args.has_key('PREC_BATHE'): + motscit['PREC_BATHE'] =args['PREC_BATHE'] + if args.has_key('NMAX_ITER_JACOBI'): + motscit['NMAX_ITER_JACOBI']=args['NMAX_ITER_JACOBI'] + if args.has_key('PREC_JACOBI'): + motscit['PREC_JACOBI'] =args['PREC_JACOBI'] + elif METHODE=='SORENSEN': + if args.has_key('NMAX_ITER_SOREN'): + motscit['NMAX_ITER_SOREN'] =args['NMAX_ITER_SOREN'] + if args.has_key('PARA_ORTHO_SOREN'): + motscit['PARA_ORTHO_SOREN']=args['PARA_ORTHO_SOREN'] + if args.has_key('PREC_SOREN'): + motscit['PREC_SOREN'] =args['PREC_SOREN'] + elif METHODE=='QZ': + if args.has_key('TYPE_QZ'): + motscit['TYPE_QZ'] =args['TYPE_QZ'] + + if CALC_FREQ['DIM_SOUS_ESPACE']: motscfa['DIM_SOUS_ESPACE']=CALC_FREQ['DIM_SOUS_ESPACE'] + if CALC_FREQ['COEF_DIM_ESPACE']: motscfa['COEF_DIM_ESPACE']=CALC_FREQ['COEF_DIM_ESPACE'] + + if CALC_FREQ['OPTION']=='PLUS_PETITE': + motscfa['NMAX_FREQ']=CALC_FREQ['NMAX_FREQ'] + + if CALC_FREQ['OPTION']=='CENTRE': + motscfa['FREQ']=CALC_FREQ['FREQ'] + if CALC_FREQ['AMOR_REDUIT']: motscfa['AMOR_REDUIT']=CALC_FREQ['AMOR_REDUIT'] + motscfa['NMAX_FREQ']=CALC_FREQ['NMAX_FREQ'] + + if CALC_FREQ['OPTION']=='BANDE': + motscfa['FREQ']=CALC_FREQ['FREQ'] + + motscit['CALC_FREQ'] = _F(OPTION =CALC_FREQ['OPTION'], + SEUIL_FREQ =CALC_FREQ['SEUIL_FREQ'], + NPREC_SOLVEUR =CALC_FREQ['NPREC_SOLVEUR'], + NMAX_ITER_SHIFT =CALC_FREQ['NMAX_ITER_SHIFT'], + PREC_SHIFT =CALC_FREQ['PREC_SHIFT'], + APPROCHE =CALC_FREQ['APPROCHE'], + **motscfa) + + motscit['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'], + SEUIL =VERI_MODE['SEUIL'], + STURM =VERI_MODE['STURM'], + PREC_SHIFT =VERI_MODE['PREC_SHIFT']) + + motscit['STOP_FREQ_VIDE'] = CALC_FREQ['STOP_FREQ_VIDE'] + + + if MODE_RIGIDE=='OUI': + mode_rigi='MODE_RIGIDE' + elif MODE_RIGIDE=='NON': + mode_rigi='SANS' + + self.DeclareOut('modes',self.sd) + + if AMORTISEMENT=='NON': + modes=MODE_ITER_SIMULT(MATR_A =_rigas, + MATR_B =_masas, + METHODE =METHODE, + OPTION =mode_rigi, + INFO =INFO, + **motscit) + elif AMORTISEMENT=='OUI': + modes=MODE_ITER_SIMULT(MATR_A =_rigas, + MATR_B =_masas, + MATR_C =_amoras, + METHODE =METHODE, + OPTION =mode_rigi, + INFO =INFO, + **motscit) + + return ier diff --git a/Aster/Cata/cataSTA9/Macro/calc_spec_ops.py b/Aster/Cata/cataSTA9/Macro/calc_spec_ops.py new file mode 100644 index 00000000..a6d669f0 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/calc_spec_ops.py @@ -0,0 +1,419 @@ +#@ MODIF calc_spec_ops Macro DATE 21/10/2008 AUTEUR CORUS M.CORUS + +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 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 copy +import types +from SD.sd_fonction import sd_fonction + +# ----------------------------------------------------------------------------- +class FonctionError(Exception): pass +class ParametreError(FonctionError): pass # probleme de NOM_PARA +class InterpolationError(FonctionError): pass +class ProlongementError(FonctionError): pass + +# ----------------------------------------------------------------------------- + + +def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): +# ------------------------------------------------------------------ +# Calcul d'une matrice interspectrale +# a partir de fonctions reelles + + import aster + from types import ListType, TupleType + EnumTypes = (ListType, TupleType) + from Accas import _F + from Utilitai.Utmess import UTMESS + import Numeric + import FFT + + commande='CALC_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 derive) 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') + +#--- Verifications sur les entrees --# + + if (ECHANT==None and TAB_ECHANT==None) : + raise FonctionError, 'Vous devez specifier des fonctions en entree' + + if TAB_ECHANT==None : TAB_ECHANT=[] + if ECHANT==None : ECHANT=[] + if INTERSPE==None : INTERSPE=[] + if TRANSFERT==None : TRANSFERT=[] + if len(TAB_ECHANT)*len(ECHANT) !=0 : + raise FonctionError, 'Vous pouvez specifier une table_fonction ou' + ' une liste de fonctions en entree, mais pas les deux' + if len(TRANSFERT)*len(INTERSPE) !=0 : + raise FonctionError, 'Vous ne pouvez specifier qu' +"'"+'un type de calcul par appel' + + + +#-- Recuperation des entrees --# + + l_f=[] + l_t=[] + l_G=[] + l_H=[] +# for occ in TAB_ECHANT : +# l_t.append(('TAB_ECHANT',occ)) + if TAB_ECHANT: #MC + l_t = TAB_ECHANT.List_F()[0] + + for occ in ECHANT : + l_f.append(('ECHANT',occ)) + for occ in INTERSPE : + l_G.append(('INTERSPE',occ)) + for occ in TRANSFERT : + l_H.append(('TRANSFERT',occ)) + + +# Pour dimensionner les fenetres : +# Cas ECHANT : on recupere simplement la premiere fonction +# Cas_TAB_ECHANT : on recupere toutes les fonctions + + if len(l_f) >0 : + vale_sig=l_f[0][1]['FONCTION'].Valeurs(); + l_ech=len(vale_sig[0]) + dt=vale_sig[0][1]-vale_sig[0][0] + else : + #tab_ast=l_t[0][1]['NOM_TAB']; + tab_ast=l_t['NOM_TAB'] #MC + tab_py=tab_ast.EXTR_TABLE(); + + nom_fonc= tab_py['FONCTION'].values()['FONCTION'] + fonc_py = [sd_fonction(fonc) for fonc in nom_fonc] + temp=fonc_py[0].VALE.get(); + dt=temp[1]-temp[0]; + + l_ech_temp=l_t['LONGUEUR_ECH']; + recouvr_temp=l_t['RECOUVREMENT']; + l_ech_t=[l_ech_temp[0]['DUREE'] , l_ech_temp[0]['POURCENT'],l_ech_temp[0]['NB_PTS'] ]; + recouvr_t=[recouvr_temp[0]['DUREE'] , recouvr_temp[0]['POURCENT'],recouvr_temp[0]['NB_PTS'] ]; + if l_ech_t.count(None)==3 : l_ech=len(temp)/2; + if recouvr_t.count(None)==3 : recouvr=0; + if l_ech_t.count(None)<2 : + raise FonctionError, 'Vous ne pouvez utiliser qu'+"'"+ 'un mot clef pour definir la longueur des echantillons' + if recouvr_t.count(None)<2 : + raise FonctionError, 'Vous ne pouvez utiliser qu'+"'"+'un mot clef pour definir la longueur de recouvrement des echantillons' + for i1 in range(3) : + if l_ech_t[i1] !=None : + if i1 == 0 : + l_ech=int(Numeric.floor(l_ech_t[i1]/dt)); + elif i1 == 1 : + l_ech=int(Numeric.floor((len(temp)/2)*l_ech_t[i1]*0.01)); + elif i1 == 2 : + l_ech=int(Numeric.floor(l_ech_t[i1])) + if l_ech > len(temp)/2 : + raise FonctionError, 'Vous devez specifier une longueur d'+"'"+'echantillon inferieure a la longueur totale de l'+"'"+'acquisition' + for i1 in range(3) : + if recouvr_t[i1] !=None : + if i1 == 0 : + recouvr=int(Numeric.floor(recouvr_t[i1]/dt)); + elif i1 == 1 : + recouvr=int(Numeric.floor((l_ech)*recouvr_t[i1]*0.01)); + elif i1 == 2 : + recouvr=int(Numeric.floor(recouvr_t[i1])) + if recouvr > l_ech : + raise FonctionError, 'La longueur de recouvrement ne peut exceder la longueur ' + +#-- Recuperation des fenetres + + for occ in l_G+l_H : + if occ[1]['FENETRE'] == 'RECT' : + fene=[1.]*l_ech + elif occ[1]['FENETRE'] == 'HAMM' : + fene=[0.54-0.46*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)] + elif occ[1]['FENETRE'] == 'HANN' : + fene=[0.5-0.5*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)] + elif occ[1]['FENETRE'] == 'EXPO' : + para=occ[1]['DEFI_FENE'] + if len(para) != 2 : + raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'la fenetre exponentielle est definie par exactement deux valeurs' + fene=[1.]*int(para[0]-1)+[Numeric.exp(para[1]*(i1-int(para[0]-1))*dt) for i1 in range(int(para[0]-1),l_ech)] + elif occ[1]['FENETRE'] == 'PART' : + fene=occ[1]['DEFI_FENE'] + if len(fene) != l_ech : + raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'La fenetre doit etre definie avec le meme nombre de points que les echantillons' + + if len(TRANSFERT)+len(INTERSPE) == 0 : #-- on ne rentre rien : interspectre par defaut - fenetre rectangulaire + fene=[1.]*l_ech + INTERSPE=1.; + + +#-- Recuperation des signaux --# +#-- Verifications et transformations de Fourier --# +#-- Entrees sous formes de table --# + + tmp=[]; + lt=[]; + frq=[]; + fft=[]; + df=[]; + num_ord=[]; + num_mes=[]; + + + if TAB_ECHANT : # Cas TAB_ECHANT + num_mes_temp= tab_py['NUME_MES'].values()['NUME_MES'] + max_mes=Numeric.maximum.reduce(num_mes_temp); + num_ord_temp= tab_py['NUME_ORDRE_I'].values()['NUME_ORDRE_I'] + long_fonc=[len(fonc_py[i1].VALE.get()) for i1 in range(len(fonc_py))] + + N_fen=int(Numeric.floor((Numeric.minimum.reduce(long_fonc)/2-l_ech)/(l_ech-recouvr))+1) + + sig=[]; + dt=[]; + for i1 in range(len(fonc_py)) : + vale=fonc_py[i1].VALE.get(); + temp=(list(vale[0:int(len(vale)/2)])); + sig.append(list(vale[int(len(vale)/2):])); + test_pas=Numeric.subtract(temp[1:],temp[0:-1]) + crit=test_pas.tolist(); + crit.sort(); + dt.append(crit[-1]); + if abs((crit[-1]-crit[0])/crit[-1]) > 1.e-5 : + raise FonctionError, 'L'+"'"+'echantillonage doit etre fait a pas constant' + + for j1 in range(N_fen) : + for i1 in range(len(fonc_py)) : + fft.append(FFT.fft(Numeric.multiply(sig[i1][j1*(l_ech-recouvr):(j1*(l_ech-recouvr)+l_ech)],fene))) + if j1 == 0 : df.append(1./(dt[i1])/l_ech); + num_mes.append(num_mes_temp[i1]+max_mes*j1); + num_ord.append(num_ord_temp[i1]); + + test_df=Numeric.subtract(df[1:],df[0:-1]) + test_df=test_df.tolist(); + test_df.sort(); + if abs(test_df[-1]) > 1.e-5 : + raise FonctionError, 'Toutes les fonctions doivent etre definies ' + 'avec la meme frequence d'+"'"+'echantillonage' + + frq = [df[-1]*i1 for i1 in range(l_ech)] + + +#-- Recuperation des signaux --# +#-- Verifications et transformations de Fourier --# +#-- Entrees sous formes de fonction --# + + if ECHANT: + for occ in l_f : + vale_sig=occ[1]['FONCTION'].Valeurs(); + #-- pour les tests ulterieurs --# + lt.append(len(vale_sig[0])) + if len(vale_sig[0]) != len(vale_sig[1]) : + raise FonctionError, 'Les vecteurs associes au temps '+'et aux echantillons doivent etre de meme longueur' + num_mes.append(occ[1]['NUME_MES']) + num_ord.append(occ[1]['NUME_ORDRE_I']) + + tmp.append(vale_sig[0]) + test_pas=Numeric.subtract(vale_sig[0][1:],vale_sig[0][0:-1]) + crit=test_pas.tolist(); + crit.sort(); + if abs((crit[-1]-crit[0])/crit[-1]) > 1.e-5 : + raise FonctionError, 'L'+"'"+'echantillonage doit etre fait a pas constant' + fft.append(FFT.fft(Numeric.multiply(vale_sig[1],fene))) + df.append(1./(crit[-1])/len(vale_sig[0])); + + + #-- Verification des longueurs --# + + test_long=Numeric.subtract(lt[1:],lt[0:-1]) + test_long=test_long.tolist(); + test_long.sort(); + if (test_long[-1]-test_long[0]) != 0 : + raise FonctionError, 'Toutes les fonctions doivent etre definies avec le meme nombre de points' + + + test_df=Numeric.subtract(df[1:],df[0:-1]) + test_df=test_df.tolist(); + test_df.sort(); + if abs(test_df[-1]) > 1.e-5 : + raise FonctionError, 'Toutes les fonctions doivent etre definies '+'avec la meme frequence d'+"'"+'echantillonage' + + frq = [df[-1]*i1 for i1 in range(lt[-1])] + + +#-- index des numeros d'ordre pour le moyennage + + uu=[]; + vv=[]; + uu=uu+num_ord; + vv=vv+num_ord; + uu.sort(); + ind_ord=[]; + list_ord=[]; + while len(uu) > 0 : + list_ord.append(uu[0]) + tt=[]; + for i1 in range(uu.count(uu[0])) : + tt.append(vv.index(uu[0])) + vv[tt[-1]]=0 + ind_ord.append(tt) + uu=uu[int(uu.count(uu[0])):] + +#-- Calcul de la matrice inter spectrale + + if len(INTERSPE) != 0 : + dimh = (len(list_ord)*(len(list_ord)+1))/2 + l_fc=[]; + nume_i1=[] + nume_j1=[] + + for i1 in range(len(list_ord)) : + for j1 in range(i1,len(list_ord)) : + #-- on ne calcule les spectres que pour des numeros de mesures correspondants + #-- Ca n'a a priori pas de sens de calculer l'interspectre entre deux signaux acquis a des instants differents + #-- Par contre, on peut moyenner deux interspectres obtenus a des instants differents, sous reserve + #-- de stationnarite et d'ergodicite du signal + mes_i1=[num_mes[k1] for k1 in ind_ord[i1]] + mes_j1=[num_mes[k1] for k1 in ind_ord[j1]] + ind_mes=[]; + #-- recuperation des indices des fft a prendre en compte pour l'interspectre + for k1 in range(len(mes_i1)) : + if mes_i1[k1] in mes_j1 : + ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]]) + + #-- Calcul des interspectres + dsp=[0.j]*l_ech; + if len(ind_mes) > 0 : + for l1 in range(len(ind_mes)) : + dsp_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][1]]) + dsp_t=Numeric.divide(dsp_t,l_ech*len(ind_mes)) + dsp=Numeric.add(dsp,dsp_t) + dsp=dsp.tolist(); + dsp_r=[]; + + for k1 in range(int(Numeric.floor(l_ech/2))) : + dsp_r=dsp_r+[frq[k1],dsp[k1].real,dsp[k1].imag] + + _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=dsp_r,); + l_fc.append(_fonc.nom) + nume_i1.append(list_ord[i1]) + nume_j1.append(list_ord[j1]) + + mcfact=[] + mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K='DSP' )) + mcfact.append(_F(PARA='OPTION' ,LISTE_K='TOUT' )) + mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dimh,) )) + mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 )) + mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 )) + mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fc )) + self.DeclareOut('tab_inte',self.sd) + tab_inte=CREA_TABLE(LISTE=mcfact, + TITRE='', + TYPE_TABLE='TABLE_FONCTION') + + +#-- Calcul des transferts + + if len(TRANSFERT) != 0 : + + l_fc=[]; + nume_i1=[] + nume_j1=[] + + #-- test sur les entrees pour les references --# + if type(l_H[0][1]['REFER'])==int : + refer=[]; + refer.append(l_H[0][1]['REFER']) + elif type(l_H[0][1]['REFER'])==tuple : + refer=list(l_H[0][1]['REFER']) + + ind_refer=[]; + dimh = len(refer)*(len(list_ord)-len(refer)) + for k1 in range(len(refer)) : + for l1 in range(len(list_ord)) : + if refer[k1] == list_ord[l1] : ind_refer.append(l1); + + #-- H1 : interspectre / autospectre + #-- H2 : autospectre / interspectre + #-- CO : coherence entre H1 et H2. + + if l_H[0][1]['ESTIM']!='HV' : + for i1 in range(len(refer)) : + for j1 in range(len(list_ord)) : + if refer[i1] != list_ord[j1] : + mes_i1=[num_mes[k1] for k1 in ind_ord[ind_refer[i1]]] #-- mesures des efforts + mes_j1=[num_mes[k1] for k1 in ind_ord[j1]] #-- mesures des reponses + ind_mes=[]; + #-- recuperation des indices des mesures a predre en compte pour les spectres + for k1 in range(len(mes_i1)) : + if mes_i1[k1] in mes_j1 : + ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]]) + + #-- Calcul des FRF + Guu=[0.j]*l_ech; + Gyy=[0.j]*l_ech; + Gyu=[0.j]*l_ech; + if len(ind_mes) > 0 : + for l1 in range(len(ind_mes)) : + Guu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][0]]) + Guu=Numeric.add(Guu,Guu_t) + Gyu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][0]]) + Gyu=Numeric.add(Gyu,Gyu_t) + Gyy_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][1]]) + Gyy=Numeric.add(Gyy,Gyy_t) + + if l_H[0][1]['ESTIM']=='H1' : + frf=Numeric.divide(Numeric.conjugate(Gyu),Guu); + nom_frf='FRF-H1'; + elif l_H[0][1]['ESTIM']=='H2' : + frf=Numeric.divide(Gyy,Gyu); + nom_frf='FRF-H2'; + elif l_H[0][1]['ESTIM']=='CO' : + H1=Numeric.divide(Numeric.conjugate(Gyu),Guu); + H2=Numeric.divide(Gyy,Gyu); + frf=Numeric.divide(H1,H2); + nom_frf='FRF-COH'; + + frf=frf.tolist(); + frf_r=[]; + + for k1 in range(int(Numeric.floor(l_ech/2))) : + frf_r=frf_r+[frq[k1],frf[k1].real,frf[k1].imag] + + _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=frf_r,); + l_fc.append(_fonc.nom) + nume_i1.append(refer[i1]) + nume_j1.append(list_ord[j1]) + + #-- On remplit la table_fonction avec tout ce qui va bien + + mcfact=[] + mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K=nom_frf )) + mcfact.append(_F(PARA='OPTION' ,LISTE_K='TOUT' )) + mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dimh,) )) + mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 )) + mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 )) + mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fc )) + self.DeclareOut('tab_inte',self.sd) + tab_inte=CREA_TABLE(LISTE=mcfact, + TITRE='', + TYPE_TABLE='TABLE_FONCTION') + diff --git a/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py new file mode 100644 index 00000000..2933aa86 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py @@ -0,0 +1,653 @@ +#@ MODIF propa_fiss_ops Macro DATE 20/10/2008 AUTEUR GALENNE E.GALENNE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 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 InterpolationLineaire(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] ) : + y0 = points[0][1] + return y0 + if ( x0 > points[n-1][0] ) : + y0 = points[n-1][1] + return y0 + 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 InterpolFondFiss(s0, Coorfo) : + """ + Interpolation des points du fond de fissure + """ + # s0 = abscisse curviligne du point considéré (0 < s0 > 1) + # Coorfo = Coordonnées du fond (extrait de la sd fiss_xfem) + # xyz = Coordonnées du point + + n = len(Coorfo) / 4 + if ( s0 < Coorfo[3] ) : + xyz = [Coorfo[0],Coorfo[1],Coorfo[2]] + return xyz + if ( s0 > Coorfo[-1] ) : + xyz = [Coorfo[-4],Coorfo[-3],Coorfo[-2]] + return xyz + i = 1 + while s0 > Coorfo[4*i+3]: + i = i+1 + xyz = [0.]*3 + xyz[0] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+0]-Coorfo[4*(i-1)+0]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+0] + xyz[1] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+1]-Coorfo[4*(i-1)+1]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+1] + xyz[2] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+2]-Coorfo[4*(i-1)+2]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+2] + return xyz + +def InterpolBaseFiss(s0, Basefo, Coorfo) : +# Interpolation de la base locale en fond de fissure +# s0 = abscisse curviligne du point considere +# Basefo = base locale du fond (VNx,VNy,VNz,VPx,VPy,VPz) +# Coorfo = Coordonnees et abscisses du fond (extrait de la sd fiss_xfem) +# en sortie : VPVNi = base locale au point considere (6 coordonnes) + n = len(Coorfo) / 4 + if ( s0 < Coorfo[3] ) : + VPVNi = Basefo[0:6] + return VPVNi + if ( s0 > Coorfo[-1] ) : + VPVNi = [Basefo[i] for i in range(-6,0)] + return VPVNi + i = 1 + while s0 > Coorfo[4*i+3]: + i = i+1 + VPVNi = [0.]*6 + for k in range(6) : + VPVNi[k] = (s0-Coorfo[4*(i-1)+3]) * (Basefo[6*i+k]-Basefo[6*(i-1)+k]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Basefo[6*(i-1)+k] + return VPVNi + + +def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): + """ + Macro PROPA_FISS + Propagation de fissure pour les modeles X-FEM : propagation par la methode de HAMILTON + ou par projection sur un maillage + """ + import aster + import string + import copy + from Accas import _F + from Utilitai.Utmess import UTMESS + from types import ListType, TupleType + from Utilitai.Table import Table, merge + from Utilitai.partition import MAIL_PY + import Numeric + from Numeric import array,asarray,Float,concatenate,sqrt,sign,resize,dot,zeros + from math import atan, atan2, cos, sin + + + EnumTypes = (ListType, TupleType) + + macro = 'PROPA_FISS' + ier=0 +#------------------------------------------------------------------ + # On importe les definitions des commandes a utiliser dans la macro + ASSE_MAILLAGE =self.get_cmd('ASSE_MAILLAGE' ) + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE' ) + CREA_TABLE =self.get_cmd('CREA_TABLE' ) + CALC_TABLE =self.get_cmd('CALC_TABLE' ) + PROPA_XFEM = self.get_cmd('PROPA_XFEM' ) + DEFI_FISS_XFEM = self.get_cmd('DEFI_FISS_XFEM' ) + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + +#------------------------------------------------------------------ +# CAS 1 : METHODE_PROPA = 'HAMILTON' +# + if METHODE_PROPA == 'HAMILTON' : + mod = args['MODELE'] + tabk = args['TABLE'] + meth = args['METHODE'] + ray = args['RAYON'] + LOI_PROPA = args['LOI_PROPA'] + if LOI_PROPA != None : + coefc = LOI_PROPA['C'] + coefm = LOI_PROPA['M'] + fiss = args['FISSURE'] + self.DeclareOut('nomfiss',fiss) + nomfiss = PROPA_XFEM(MODELE=mod, + TABLE=tabk, + METHODE=meth, + LOI_PROPA=_F(LOI='PARIS', + C=coefc, + M=coefm), + RAYON=ray, + INFO=INFO,) + +#------------------------------------------------------------------ +# CAS 2 : METHODE_PROPA = 'MAILLAGE' +# + ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','O','P','Q','R','S','T','U','V','W','X','Y','Z']; + + if METHODE_PROPA == 'MAILLAGE' : + fiss = args['FISSURE1'] + LOI_PROPA = args['LOI_PROPA'] + MA_XFEM1 = args['MA_XFEM1'] + if LOI_PROPA != None : + coef_paris = LOI_PROPA['M'] + Damax = LOI_PROPA['DA_MAX'] + coef_C = LOI_PROPA['C'] + it = args['ITERATION'] + typmod= MA_XFEM1.DIME.get() + typmod = typmod[5] + +# Verification qu on a bien un fond unique + Fissmult = fiss.FONDMULT.get() + Nbfiss = len(Fissmult)/2 + if Nbfiss >1 : + UTMESS('F','RUPTURE1_48',vali=Nbfiss) + +# Recuperation des K et calcul de DeltaK + Nmeth = args['METHODE_POSTK'] + SIF = args['TABLE'] + hypo = args['HYPOTHESE'] + nbinst = 1 +# A- TABLEAU ISSSU DE POST_K1_K2_K3 + if (Nmeth != None) : + __TABN = CALC_TABLE(TABLE=SIF,ACTION=_F(OPERATION='FILTRE', + NOM_PARA='METHODE',VALE_I=Nmeth),); + __tabp = __TABN.EXTR_TABLE() + if ('K1_MAX' not in __tabp.para) or ('G_MAX' not in __tabp.para): + UTMESS('F','RUPTURE1_44') + __tab1 = __tabp.values() + if 'INST' in __tabp.para : + l_inst_tab=__tabp['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() + nbinst = len(l_inst_tab) + if nbinst > 1 : + nbfis = len(__tab1['K1_MAX']) / nbinst + DK1 = [None]*nbfis + DKmax = 0. + for k in range(nbfis) : + DK1[k]=[0.]*2 + __tmp = __tabp.PT_FOND==(k+1) + if (typmod == 3) : DK1[k][0]=__tmp.values()['ABSC_CURV'][0] + DK1[k][1]=max(__tmp.values()['K1_MAX'])-min(__tmp.values()['K1_MAX']) + DKmax = max(DKmax,DK1[k][1]) + else : + nbfis = len(__tab1['K1_MAX']) + if hypo == 'NON_PLAN' : + BETA = [None]*nbfis + if (min(__tab1['G_MAX']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKmax = max(sqrt(__tab1['G_MAX'])) + BETA = [0.]*nbfis + absc = [0.]*nbfis + for i in range(nbfis) : + k1 = __tab1['K1_MAX'][i] + k2 = __tab1['K2_MAX'][i] + if (typmod == 3) : absc[i]=__tab1['ABSC_CURV'][i] + BETA[i] = [absc[i] , 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8)))] + DK1 = [[absc[i],sqrt(__tab1['G_MAX'][i])] for i in range(nbfis)] + else : + DKmax = max(__tab1['K1_MAX']) + if (typmod == 3) : + DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_MAX'][i]] for i in range(nbfis)] + else : + DK1 = [[0.,__tab1['K1_MAX'][i]] for i in range(nbfis)] + if (min(__tab1['K1_MAX']) < 0.) : + UTMESS('F','RUPTURE1_49') +# B- TABLEAU ISSSU DE CALC_G (option CALC_K_G) + else : + __tabp = SIF.EXTR_TABLE() + if (typmod == 3) and (('K1_LOCAL' not in __tabp.para) or ('G_LOCAL' not in __tabp.para) or ('BETA_LOCAL' not in __tabp.para)): + UTMESS('F','RUPTURE1_45') + if (typmod == 2) and (('K1' not in __tabp.para) or ('G' not in __tabp.para)) : + UTMESS('F','RUPTURE1_45') + __tab1= __tabp.values() + if 'INST' in __tabp.para : + l_inst_tab=__tabp['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() + nbinst = len(l_inst_tab) + if nbinst > 1 : + nbfiss = 1 + if (typmod == 3) : nbfis = len(__tab1['K1_LOCAL']) / nbinst + DK1 = [None]*nbfis + DKmax = 0. + for k in range(nbfis) : + DK1[k]=[None]*2 + __tmp = __tabp.NUM_PT==(k+1) + if (typmod == 3) : + DK1[k][0]=__tmp.values()['ABSC_CURV'][0] + DK1[k][1]=max(__tmp.values()['K1_LOCAL'])-min(__tmp.values()['K1_LOCAL']) + else : + DK1[k][0]=0. + DK1[k][1]=max(__tmp.values()['K1'])-min(__tmp.values()['K1']) + DKmax = max(DKmax,DK1[k][1]) + elif typmod == 3 : + nbfis = len(__tab1['K1_LOCAL']) + if hypo == 'NON_PLAN' : + if (min(__tab1['G_LOCAL']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKmax = max(sqrt(__tab1['G_LOCAL'])) + DK1 = [[__tab1['ABSC_CURV'][i],sqrt(__tab1['G_LOCAL'][i])] for i in range(nbfis)] + BETA = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbfis)] + else : + DKmax = max(__tab1['K1_LOCAL']) + DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_LOCAL'][i]] for i in range(nbfis)] + if (min(__tab1['K1_LOCAL']) < 0.) : + UTMESS('F','RUPTURE1_49') + else : + nbfis = 1 + if hypo == 'NON_PLAN' : + if (min(__tab1['G']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKmax = max(sqrt(__tab1['G'])) + DK1 = [[0.,DKmax],] + k1 = __tab1['K1'][0] + k2 = __tab1['K2'][0] + beta = 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8))) + BETA = [[0.,beta] ] + else : + DKmax = max(__tab1['K1']) + DK1 = [[0.,DKmax ] ,] + if (min(__tab1['K1']) < 0.) : + UTMESS('F','RUPTURE1_49') + + if hypo == 'NON_PLAN' and nbinst > 1 : + UTMESS('F','RUPTURE1_47') + +#------------------------------------------------------------------ +# CAS 2a : MODELE 3D +# + if typmod == 3 : + mm = MAIL_PY() + mm.FromAster(MA_XFEM1) + +# Recuperation des informations sur le maillage + nbno = mm.dime_maillage[0] + nbma = mm.dime_maillage[2] + collgrma = mm.gma + nbnofo = len(collgrma['FOND_0'])+1 + +# Correction de la position des noeuds (equirepartition) + Coorfo = fiss.FONDFISS.get() + absmax = Coorfo[-1] + abscf = [0.]*nbnofo + for i in range(nbnofo) : + abscf[i] = i * absmax / (nbnofo-1) + xyzi = InterpolFondFiss(abscf[i], Coorfo) + mm.cn[nbno-nbnofo+i][0] = xyzi[0] + mm.cn[nbno-nbnofo+i][1] = xyzi[1] + mm.cn[nbno-nbnofo+i][2] = xyzi[2] + +# Maillage apres correction + coord = mm.cn + linomno = list(mm.correspondance_noeuds) + linomno = map(string.rstrip,linomno) + l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] + d_coorf = dict(l_coorf) + +# Boucle sur le fond : coordonnees du point propage + Basefo = fiss.BASEFOND.get() + Listfo = fiss.FONDFISS.get() + Vorig = args['DTAN_ORIG'] + Vextr = args['DTAN_EXTR'] + if (Damax ==None) : + DKmax = 1 + if (coef_C ==None) : + coef_C = Damax + for ifond in range(nbnofo) : + Xf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][0] + Yf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][1] + Zf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][2] + + VPVNi = InterpolBaseFiss(abscf[ifond],Basefo, Listfo) + + k1 = InterpolationLineaire(abscf[ifond], DK1) + if k1<=0 : + UTMESS('F','RUPTURE1_49') + +# Correction pour reduire le risque de maille aplatie (pilotage par Damax uniquement) + if (Damax !=None) : + Damin = Damax /10. + if ((k1/DKmax)**coef_paris <= Damin ) : + k1 = Damin**(1/coef_paris)*DKmax + +# Tangentes aux extremites + if (ifond == 0) and (Vorig != None) : + VPVNi[3] = Vorig[0] + VPVNi[4] = Vorig[1] + VPVNi[5] = Vorig[2] + if (ifond == nbnofo-1) and (Vextr != None) : + VPVNi[3] = Vextr[0] + VPVNi[4] = Vextr[1] + VPVNi[5] = Vextr[2] + + if hypo == 'NON_PLAN' : + beta = InterpolationLineaire(abscf[ifond], BETA) + Xf2 = Xf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris + Yf2 = Yf + coef_C*(VPVNi[4]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris + Zf2 = Zf + coef_C*(VPVNi[5]*cos(beta)+VPVNi[2]*sin(beta))*(k1/DKmax)**coef_paris + else : + Xf2 = Xf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris + Yf2 = Yf + coef_C*VPVNi[4]*(k1/DKmax)**coef_paris + Zf2 = Zf + coef_C*VPVNi[5]*(k1/DKmax)**coef_paris + + LesNoeudsEnPlus = array([[Xf2,Yf2,Zf2]]) + if ifond ==0 : + Pini = (Xf2,Yf2,Zf2) + vectorie = (VPVNi[0],VPVNi[1],VPVNi[2],) + NomNoeudsEnPlus = ['NX%s%i' %(ALPHABET[ifond],it+1)] + mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple( list(mm.correspondance_noeuds) + NomNoeudsEnPlus ) + +# Ajout Maille lèvre (quad4) + nbnotot = len(mm.correspondance_noeuds) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbnofo-1) : + NomMaillesEnPlus.append( 'MX%s%i' %(ALPHABET[ifond], it+1) ) + num_maille.append( [ nbma + ifond +1 ] ) + num_maille.append( nbma +ifond + 1 ) + i1 = nbnotot - 2*nbnofo + ifond + i2 = nbnotot - 2*nbnofo + ifond +1 + i3 = nbnotot - nbnofo + ifond +1 + i4 = nbnotot - nbnofo + ifond + NoeudsMailles.append( array([i1,i2,i3,i4])) + + typ_maille = mm.dic['QUAD4'] + NbMailleAjoute = nbnofo-1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + fsi = mm.gma['FISS_%i' %(it-1)] + for ifond in range(nbnofo-1) : + fsi = concatenate((fsi,array([nbma+ifond]))) + mm.gma['FISS_%i' %it] = fsi + +# Ajout Maille fond (SEG2) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbnofo-1) : + NomMaillesEnPlus.append( 'MF%s%i' %(ALPHABET[ifond], it+1) ) + num_maille.append( [ nbma + ifond +nbnofo ] ) + num_maille.append( nbma + ifond + nbnofo ) + i3 = nbnotot - nbnofo + ifond + i4 = nbnotot - nbnofo + ifond +1 + NoeudsMailles.append( array([i3,i4])) + + typ_maille = mm.dic['SEG2'] + NbMailleAjoute = nbnofo-1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + fsi = [] + for ifond in range(nbnofo-1) : + fsi = concatenate((fsi,array([nbma+ifond+nbnofo-1]))) + mm.gma['FOND_%i' %it] = fsi + +#------------------------------------------------------------------ +# CAS 2b : MODELE 2D +# + if typmod == 2 : + mm = MAIL_PY() + mm.FromAster(MA_XFEM1) + + (nno,ndim) = mm.cn.shape + +# Recuperation des informations sur le maillage + nbno = mm.dime_maillage[0] + nbma = mm.dime_maillage[2] + coord = mm.cn + linomno = list(mm.correspondance_noeuds) + linomno = map(string.rstrip,linomno) + l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] + d_coorf = dict(l_coorf) + +# Coordonnees du point propage + Xf = d_coorf['NXA%i' %(it)][0] + Yf = d_coorf['NXA%i' %(it)][1] + if (Damax ==None) : + DKmax = 1 + if (coef_C ==None) : + coef_C = Damax + + VPVNi = fiss.BASEFOND.get() + k1 = DK1[0][1] + if hypo == 'NON_PLAN' : + beta = BETA[0][1] + Xf2 = Xf + coef_C*(VPVNi[2]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris + Yf2 = Yf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris + else : + Xf2 = Xf + coef_C*VPVNi[2]*(k1/DKmax)**coef_paris + Yf2 = Yf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris + + LesNoeudsEnPlus = array([[Xf2,Yf2]]) + NomNoeudsEnPlus = ['NXA%i' %(it+1)] + mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus ) + +# Ajout Maille lèvre (SEG2) + NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it+1)] + num_maille = [ nbma + 1 ] + num_maille.append( nbma + 1 ) + NoeudsMailles = [array([nbno-1,nbno])] + typ_maille = mm.dic['SEG2'] + NbMailleAjoute = 1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + fsi = mm.gma['FISS_%i' %(it-1)] + fsi = concatenate((fsi,array([nbma]))) + mm.gma['FISS_%i' %it] = fsi + +# Ajout Maille fond (POI1) + NomMaillesEnPlus = ['MF%s%i' %(ALPHABET[0], it+1)] + num_maille = [ nbma + 2 ] + NoeudsMailles = [array([nbno])] + typ_maille = mm.dic['POI1'] + mm.tm = concatenate((mm.tm,array([typ_maille]*1))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + mm.gma['FOND_%i' %it] = array(nbma+1) + +# Fin du 2D + if INFO==2 : + texte="Maillage produit par l operateur PROPA_FISS" + aster.affiche('MESSAGE',texte) + print mm + +# Sauvegarde (maillage xfem et maillage concatene) + MA_XFEM2 = args['MA_XFEM2'] + if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2) + __MA = mm.ToAster(unite=39) + self.DeclareOut('ma_xfem2',MA_XFEM2) + ma_xfem2=LIRE_MAILLAGE(UNITE=39); + + MA_TOT2 = args['MA_TOT2'] + if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2) + MA_STRUC = args['MA_STRUC'] + ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC, + MAILLAGE_2 = ma_xfem2, + OPERATION='SUPERPOSE') + +#------------------------------------------------------------------ +# CAS 3 : METHODE_PROPA = 'INITIALISATION' +# + if METHODE_PROPA == 'INITIALISATION' : + form = args['FORM_FISS'] + +# 3-a : demi-droite + if form == 'DEMI_DROITE' : + PF = args['PFON'] + DTAN = args['DTAN'] + PI = array([[PF[0]-DTAN[0],PF[1]-DTAN[1]],]) + + ndim = 2 + mm = MAIL_PY() + mm.__init__() + +# Ajout des noeuds + LesNoeudsEnPlus = concatenate((PI,array([PF[0:2]]))) + NomNoeudsEnPlus = ['NXA0','NXA1'] + mm.cn = LesNoeudsEnPlus + mm.correspondance_noeuds = tuple( NomNoeudsEnPlus ) + +# Ajout Maille lèvre (SEG2) + it = 1 + nbma = 0 + nbno = 0 + NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it)] + num_maille = [ nbma + 1 ] + num_maille.append( nbma + 1 ) + NoeudsMailles = [array([nbno,nbno+1])] + typ_maille = mm.dic['SEG2'] + NbMailleAjoute = 1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + mm.gma['FISS_0'] = array(nbma) + +# Ajout Maille fond (POI1) + NomMaillesEnPlus = ['MF%s%i' %(ALPHABET[0], it)] + num_maille = [ nbma + 2 ] + NoeudsMailles = [array([nbno+1])] + typ_maille = mm.dic['POI1'] + mm.tm = concatenate((mm.tm,array([typ_maille]*1))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + mm.gma['FOND_0'] = array(nbma+1) + + +# 3-b : demi-plan + if form == 'DEMI_PLAN' : + P0 = args['POINT_ORIG'] + P1 = args['POINT_EXTR'] + dpropa = args['DTAN'] + nbpt = args['NB_POINT_FOND'] + Q0 = array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]]) + + mm = MAIL_PY() + mm.__init__() + x=[None]*nbpt + y=[None]*nbpt + z=[None]*nbpt + xx=[None]*nbpt + yy=[None]*nbpt + zz=[None]*nbpt + LesNoeudsEnPlus = Q0 + NomNoeudsEnPlus = ['NXA0'] + mm.cn = LesNoeudsEnPlus + mm.correspondance_noeuds = tuple( NomNoeudsEnPlus ) + + for i in range(1,nbpt) : + x[i] = P0[0]+i*(P1[0]-P0[0])/(nbpt-1) + y[i] = P0[1]+i*(P1[1]-P0[1])/(nbpt-1) + z[i] = P0[2]+i*(P1[2]-P0[2])/(nbpt-1) + xx[i] = x[i] - dpropa[0] + yy[i] = y[i] - dpropa[1] + zz[i] = z[i] - dpropa[2] + LesNoeudsEnPlus = array([[xx[i],yy[i],zz[i]]]) + NomNoeudsEnPlus = ['NX%s0' %(ALPHABET[i]) ] + mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) +NomNoeudsEnPlus ) + LesNoeudsEnPlus = array([P0]) + NomNoeudsEnPlus = ['NXA1'] + mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) + NomNoeudsEnPlus ) + for i in range(1,nbpt) : + LesNoeudsEnPlus = array([[x[i],y[i],z[i]]]) + NomNoeudsEnPlus = ['NX%s1' %(ALPHABET[i]) ] + mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) +NomNoeudsEnPlus ) + +# Ajout Maille lèvre (quad4) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbpt-1) : + NomMaillesEnPlus.append( 'MX%s1' %(ALPHABET[ifond]) ) + num_maille.append( [ ifond +1 ] ) + num_maille.append( ifond + 1 ) + i1 = ifond + i2 = ifond+1 + i3 = nbpt+ifond + i4 = nbpt+ifond+1 + NoeudsMailles.append( array([i1,i2,i4,i3])) + + typ_maille = mm.dic['QUAD4'] + NbMailleAjoute = nbpt-1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + fsi =[] + for ifond in range(nbpt-1) : + fsi = concatenate((fsi,array([ifond]))) + mm.gma['FISS_0' ] = fsi + +# Ajout Maille fond (SEG2) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbpt-1) : + NomMaillesEnPlus.append( 'MF%s1' %(ALPHABET[ifond]) ) + num_maille.append( [ ifond +nbpt ] ) + num_maille.append( ifond + nbpt ) + i3 = nbpt+ifond + i4 = nbpt+ifond+1 + NoeudsMailles.append( array([i3,i4])) + + typ_maille = mm.dic['SEG2'] + NbMailleAjoute = nbpt-1 + mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + fsi = [] + for ifond in range(nbpt-1) : + fsi = concatenate((fsi,array([ifond+nbpt-1]))) + mm.gma['FOND_0'] = fsi + + + if INFO==2 : + texte="Maillage produit par l operateur PROPA_FISS" + aster.affiche('MESSAGE',texte) + print mm + +# Sauvegarde (maillage xfem et maillage concatene) + MA_XFEM2 = args['MA_XFEM2'] + if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2) + __MA = mm.ToAster(unite=39) + self.DeclareOut('ma_xfem2',MA_XFEM2) + ma_xfem2=LIRE_MAILLAGE(UNITE=39); + + MA_TOT2 = args['MA_TOT2'] + if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2) + MA_STRUC = args['MA_STRUC'] + ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC, + MAILLAGE_2 = ma_xfem2, + OPERATION='SUPERPOSE') + + return diff --git a/Aster/Cata/cataSTA9/Macro/test_temps_ops.py b/Aster/Cata/cataSTA9/Macro/test_temps_ops.py new file mode 100644 index 00000000..0723b830 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/test_temps_ops.py @@ -0,0 +1,251 @@ +#@ MODIF test_temps_ops Macro DATE 05/09/2008 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 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 COURTOIS M.COURTOIS + +""" +for m in clpaster clp50a8 claut626 clau5aaa aster +do + echo "------ $m : `ssh $m hostid` -------" + ssh $m cat /proc/cpuinfo > $m.cpuinfo + ssh $m python -c '"import os ; print os.uname()[-1]"' + grep 'cpu MHz' $m.cpuinfo | head -1 + grep -i bogomips $m.cpuinfo | head -1 +done +""" + +import sys +import os +import re +from glob import glob + +#------------------------------------------------------------------------------- +# formats +tab_header = """ + !--------------------------------------------------------------------------------------------------! + ! Commande ! Ordre ! Reference ! Mesure ! Difference ! Tolerance ! Diagnostic ! + !--------------------------------------------------------------------------------------------------!""" +tab_line = """ ! %(cmde)-22s ! %(nume)6d ! %(refe)10.2f ! %(vale)10.2f ! %(diff)10.2f ! %(prec)10.2f ! %(diag)4s !""" +tab_footer = """ !--------------------------------------------------------------------------------------------------! +""" + +#------------------------------------------------------------------------------- +def get_idperf(conf): + """Retourne l'identifiant utilisé pour la mesure des performances. + Soit on le trouve dans le fichier config.txt de la version utilisée, + soit on le détermine à partir de : "kernel name - hardware name" + """ + machine = '' + compiler = 'unknown' + if conf is not None: + machine = conf['ID_PERF'][0] + compiler = os.path.basename(conf['F77'][0].split()[0]) + + if machine == '': + machine = '%s-%s-%s' %(os.uname()[0], os.uname()[4], compiler) + return machine + +#------------------------------------------------------------------------------- +def as_list(value): + """Retourne 'value' si c'est une liste, sinon le singleton [value,].""" + if type(value) not in (list, tuple): + value = [value,] + return value + +#------------------------------------------------------------------------------- +def test_temps_ops(self, RESU, INFO, **args): + """ + Macro TEST_TEMPS permettant de vérifier le temps passé dans les commandes. + """ + import aster + from Accas import _F + from Utilitai.Utmess import UTMESS, MessageLog + from Utilitai.System import ExecCommand + + # On importe les definitions des commandes a utiliser dans la macro + # Le nom de la variable doit etre obligatoirement le nom de la commande + DETRUIRE = self.get_cmd('DETRUIRE') + CREA_TABLE = self.get_cmd('CREA_TABLE') + TEST_TABLE = self.get_cmd('TEST_TABLE') + + #---------------------------------------------- + ier = 0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # ----- récupération du fichier de config + ficconf = '?' + conf = None + try: + # recuperation de la variable ASTER_ROOT + aster_root = os.environ.get('ASTER_ROOT') + assert aster_root != None, " Variable d'environnement ASTER_ROOT non definie." + sys.path.append(os.path.join(aster_root, 'ASTK', 'ASTK_SERV', 'lib')) + from as_profil import ASTER_PROFIL + from as_config import ASTER_CONFIG + + l_export = glob('*.export') + assert len(l_export) > 0, " pas de fichier export dans le repertoire de travail." + + ficconf = 'config.txt' + if not os.path.isfile(ficconf): # if as_run.__version__ < 1.6.3 + prof = ASTER_PROFIL(l_export[0]) + if prof.Get('D', typ='conf'): + print ' Surcharge du fichier config.txt non supportée.' + REPREF = os.path.join(aster_root, prof['version'][0]) + ficconf = os.path.join(REPREF, 'config.txt') + conf = ASTER_CONFIG(ficconf) + except Exception, err: + print err + + machine = get_idperf(conf) + + # liste des timers par ordre d'apparition : dict_cmde['commande'] = [timer1, timer2, ...] + dict_cmde = {} + for num, timer in self.jdc.timer.getsortedtimers(): + cmde = timer['name'] + dict_cmde[cmde] = dict_cmde.get(cmde, []) + dict_cmde[cmde].append(timer) + + tab = get_cmde_timers(self.jdc) + if INFO == 2: + aster.affiche('MESSAGE', repr(tab)) + + #---------------------------------------------- + # boucle sur les commandes a tester + alarm9 = True + infos = [] + for res_i in RESU: + dres = res_i.cree_dict_valeurs(res_i.mc_liste) + current = { + 'cmde' : dres['COMMANDE'], + 'nume' : dres['NUME_ORDRE'], + 'refe' : 0., + 'vale' : 0., + 'diff' : 0., + 'prec' : 0., + 'diag' : 'NOOK', + } + error = False + l_mach = as_list(dres['MACHINE']) + l_vale = as_list(dres['VALE']) + if len(l_mach) != len(l_vale): + UTMESS('E', 'TEST0_10') + error = True + + l_prec = as_list(dres['PRECISION']) + if len(l_prec) == 1: + l_prec = l_prec * len(l_vale) + if len(l_prec) != len(l_vale): + UTMESS('E', 'TEST0_8') + error = True + + tres = (tab.COMMANDE == dres['COMMANDE']) & (tab.NUME_ORDRE == dres['NUME_ORDRE']) + if len(tres) != 1: + UTMESS('E', 'TEST0_7', valk=dres['COMMANDE'], vali=dres['NUME_ORDRE']) + error = True + + if error: + infos.append(current) + continue + + # comparaison des valeurs + valtest = getattr(tres, dres['TYPE_TEST']) + assert len(valtest) == 1, 'TYPE_TEST invalide' + valtest = valtest[0] + + current['vale'] = valtest + + # reference, precision + dref = {} + for mach, vale, precision in zip(l_mach, l_vale, l_prec): + if dres['CRITERE'] == 'RELATIF': + precision = precision * vale + dref[mach.upper()] = { + 'vale' : vale, + 'prec' : precision, + 'valmin' : vale - precision, + 'valmax' : vale + precision + } + dmach = dref.get(machine.upper()) + # si on n'a pas de référence pour cette machine, on prend la première + if not dmach: + dmach = dref[l_mach[0].upper()] + if alarm9: + alarm9 = False + UTMESS('A', 'TEST0_9', valk=(machine, l_mach[0])) + current['refe'] = dmach['vale'] + current['prec'] = dmach['prec'] + current['diff'] = valtest - dmach['vale'] + if dmach['valmin'] < valtest < dmach['valmax']: + current['diag'] = 'OK' + infos.append(current) + + # tableau de resultats + text_id = MessageLog.GetText('I', 'TEST0_5', valk=(ficconf, machine)) + is_ok = 1 + txt = [text_id, tab_header,] + for line in infos: + txt.append(tab_line % line) + if line['diag'] != 'OK': + is_ok = 0 + txt.append(tab_footer) + for unit in ('MESSAGE', 'RESULTAT'): + aster.affiche(unit, os.linesep.join(txt)) + + # test_resu + tab1__ = CREA_TABLE(LISTE=(_F(PARA='DIAGNOSTIC', LISTE_I=is_ok),),) + + TEST_TABLE(TABLE=tab1__, + NOM_PARA='DIAGNOSTIC', + VALE_I=1, + CRITERE='ABSOLU', + PRECISION=0,) + + return ier + + +#------------------------------------------------------------------------------- +def get_cmde_timers(jdc): + """Retourne un objet Table contenant les mesures de temps pour + les commandes terminées. + """ + from Utilitai.Table import Table + tab = Table() + + # liste des timers par ordre d'apparition + dnum = {} + for num, timer in jdc.timer.getsortedtimers(): + if timer['state'] != 'stop' \ + or re.sub('[A-Z_]', '', timer['name']).strip() != '': # timers superviseur + continue + line = {} + for k in ('name', 'cpu_dt', 'sys_dt', 'tot_dt'): + line[k] = timer[k] + line['USER+SYS'] = timer['cpu_dt'] + timer['sys_dt'] + dnum[line['name']] = dnum.get(line['name'], 0) + 1 + line['NUME_ORDRE'] = dnum[line['name']] + tab.append(line) + tab.Renomme('name', 'COMMANDE') + tab.Renomme('cpu_dt', 'USER') + tab.Renomme('sys_dt', 'SYSTEM') + tab.Renomme('tot_dt', 'ELAPSED') + tab = tab['NUME_ORDRE', 'COMMANDE', 'USER', 'SYSTEM', 'USER+SYS', 'ELAPSED'] + return tab + diff --git a/Aster/prefs.py b/Aster/prefs.py index 10c83d2b..ec764605 100644 --- a/Aster/prefs.py +++ b/Aster/prefs.py @@ -19,7 +19,6 @@ # # ====================================================================== -print "import des prefs de Aster" import os,sys # REPINI sert à localiser le fichier editeur.ini -- 2.39.2