--- /dev/null
+#@ 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)<i+1 :
+ listType.append('DKT3')
+ except :
+ err+=1
+ if err<2 :
+ i+=1
+ else :
+ break
+ # if 'DKT3' in self.modelisations :
+ # try :
+ # __SIG21 = LIRE_CHAMP(
+ # INFO = self.INFO,
+ # TYPE_CHAM = 'ELGA_SIEF_R',
+ # UNITE = 99,
+ # NUME_PT = i*pas,
+ # MODELE = self.NEW_MODELE,
+ # MAILLAGE = self.reupere_structure(self.MODELE,'MAILLAGE'),
+ # PROL_ZERO = 'OUI',
+ # NOM_MED = 'CHAMP___CONTRAINTE___00%d'%index,
+ # NOM_CMP = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
+ # NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']),
+ # dicDetr.append({'NOM' : __SIG21})
+
+ # except :
+ # err +=1
+ # if err > 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 ----------------------------
+#------------------------------------------------------------------------
--- /dev/null
+#@ 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
