Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py

   1 #@ MODIF calc_europlexus_ops Macro  DATE 18/11/2009   AUTEUR MACOCCO K.MACOCCO
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 # ======================================================================
  20 # RESPONSABLE ASSIRE A.ASSIRE
  21
  22 #-----------------------------------------------------------------------
  23 #----------------------------- Importation des modules  ----------------
  24 #-----------------------------------------------------------------------
  25
  26 # unite associe au fichier ou le pos-traitement CASTE2000 est fait en commandes epx
  27 # unite_cast2000 = 0 # il ne fait pas le pos-traitement
  28 # __temp
  29 unite_cast2000 = 95
  30
  31 debug = False
  32 dryrun = False
  33
  34 import types,string
  35 import os
  36 import Numeric as N
  37 import math
  38 import copy
  39 import sets
  40
  41 # Protection pour Eficas
  42 try:
  43    import aster
  44    from Accas import _F
  45    from Utilitai.partition import MAIL_PY
  46    from Utilitai.Utmess import UTMESS
  47 except:
  48   pass
  49
  50 #----------------------------- Precision -------------------------------
  51 tst = 1.0E-10
  52
  53 #-----------------------------------------------------------------------
  54 #----------------------------- Fonctions de calcul vectoriel -----------
  55 #-----------------------------------------------------------------------
  56
  57 def norme(u) :
  58   return N.sqrt(N.dot(u,u))
  59
  60 def vecteurs_egaux(v1,v2):
  61   diff = v1-v2
  62   #print 'v1',v1
  63   #print 'v2',v2
  64   for v in diff:
  65     if abs(v) > tst : return False
  66   return True
  67
  68 #-----------------------------------------------------------------------
  69 #----------------------------- Operateur de la Macro-commande ----------
  70 #-----------------------------------------------------------------------
  71
  72
  73 def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None,
  74                              DIME=None,OBSERVATION=None,ARCHIVAGE=None,COURBE=None,
  75                              CALCUL=None,DOMAINES=None,INTERFACES=None,INFO=1,**args):
  76
  77 #   import aster
  78 #   from Accas import _F
  79
  80   ier=0
  81   # La macro compte pour 1 dans la numerotation des commandes
  82   self.set_icmd(1)
  83
  84   # On importe les definitions des commandes a utiliser dans la macro
  85   # Le nom de la variable doit etre obligatoirement le nom de la commande
  86
  87   global _F,INFO_EXEC_ASTER,DETRUIRE,IMPR_RESU,DEFI_FICHIER,LIRE_RESU,CREA_MAILLAGE
  88   global DEFI_GROUP,LIRE_MAILLAGE,CREA_TABLE,IMPR_TABLE,AFFE_MODELE,EXEC_LOGICIEL
  89   global LIRE_CHAMP,CREA_CHAMP,CREA_RESU,FORMULE
  90
  91   INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER')
  92   DETRUIRE        = self.get_cmd('DETRUIRE')
  93   IMPR_RESU       = self.get_cmd('IMPR_RESU')
  94   DEFI_FICHIER    = self.get_cmd('DEFI_FICHIER')
  95   LIRE_RESU       = self.get_cmd('LIRE_RESU')
  96   CREA_MAILLAGE   = self.get_cmd('CREA_MAILLAGE')
  97   DEFI_GROUP      = self.get_cmd('DEFI_GROUP')
  98   LIRE_MAILLAGE   = self.get_cmd('LIRE_MAILLAGE')
  99   CREA_TABLE      = self.get_cmd('CREA_TABLE')
 100   IMPR_TABLE      = self.get_cmd('IMPR_TABLE')
 101   AFFE_MODELE     = self.get_cmd('AFFE_MODELE')
 102   EXEC_LOGICIEL   = self.get_cmd('EXEC_LOGICIEL')
 103   LIRE_CHAMP      = self.get_cmd('LIRE_CHAMP')
 104   CREA_CHAMP      = self.get_cmd('CREA_CHAMP')
 105   CREA_RESU       = self.get_cmd('CREA_RESU')
 106   FORMULE         = self.get_cmd('FORMULE')
 107
 108   # Pour la gestion des Exceptions
 109   prev_onFatalError = aster.onFatalError()
 110   aster.onFatalError('EXCEPTION')
 111
 112
 113   # Pour masquer certaines alarmes
 114   from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
 115   MasquerAlarme('MED_1')
 116
 117   # Ligne de commande d'Europlexus
 118   if args.has_key('LOGICIEL'): EXEC = args['LOGICIEL']
 119   else: EXEC = '/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'
 120   if debug: print 'args_keys : %s'%args.keys()
 121   if args.has_key('PAS_NBRE_COURBE') :
 122      if debug: print 'PAS NBRE COURBE = ok (%s)'%args['PAS_NBRE_COURBE']
 123   else :
 124      if debug: print 'PAS NBRE COURBE = nook'
 125   # La macro compte pour 1 dans la numerotation des commandes
 126   self.set_icmd(1)
 127
 128   # classs Europlexus permettant de faire le chainage avec le Code_Aster
 129   EPX = EUROPLEXUS(MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,
 130 # AA                   ECRITURE,CALCUL,REPE='REPE_OUT',EXEC=EXEC)
 131                    OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES,
 132                    REPE='REPE_OUT',EXEC=EXEC, INFO=INFO, args=args)
 133
 134   # Eriture du fichier de commande Europlexus
 135   EPX.ecrire_fichier()
 136
 137   # Si dryrun alors on ne lance pas le calcul Europlexus
 138   if dryrun: return ier
 139
 140   # Lancement du calcul Europlexus
 141   EPX.lancer_calcul()
 142
 143   # Recuperer le resulat Europlexus a l'aide d'un concept aster de type evol_noli
 144   fichier_med = 'auto'
 145   fichier_pun = 'auto'
 146 #  if debug  :
 147 #    fichier_med='fort.81'
 148 #    fichier_pun ='fort.85'
 149
 150   self.DeclareOut('resu',self.sd) # Le concept sortant (de type evol_noli) est nomme 'resu'
 151   global resu # pour que le nom du concept prenne celui defini par l'utilisateur
 152   EPX.get_resu(fichier_med=fichier_med)
 153
 154   #Recuperer les concepts table
 155   if COURBE is not None:
 156     global table
 157     # icourbe = 0
 158     # for fonc in COURBE['TABLE'] :
 159       # icourbe += 1
 160     self.DeclareOut('table',args['TABLE_COURBE'])
 161     EPX.get_table()
 162       # EPX.get_table(icourbe=icourbe,fichier=fichier_pun)
 163
 164
 165   # Pour la gestion des Exceptions
 166   aster.onFatalError(prev_onFatalError)
 167
 168   # Pour la gestion des alarmes
 169   RetablirAlarme('MED_1')
 170
 171   return ier
 172
 173 #-----------------------------------------------------------------------
 174 #----------------------------- class EUROPLEXUS ------------------------
 175 #-----------------------------------------------------------------------
 176
 177 class EUROPLEXUS:
 178 # AA  def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,ECRITURE,CALCUL,REPE,EXEC,**args):
 179   def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES,REPE,EXEC,INFO,args):
 180
 181     if debug: print 'args_key %s'%args.keys()
 182     # Mettre toutes les entrees en attributs
 183     self.DIME = DIME
 184     self.MODELE = MODELE
 185     self.CARA_ELEM = CARA_ELEM
 186     self.CHAM_MATER = CHAM_MATER
 187     self.FONC_PARASOL = FONC_PARASOL
 188     self.EXCIT = EXCIT
 189 #    self.ECRITURE = ECRITURE
 190     self.OBSERVATION = OBSERVATION
 191     self.ARCHIVAGE = ARCHIVAGE
 192     self.COURBE = COURBE
 193     self.CALCUL = CALCUL
 194     self.DOMAINES = DOMAINES
 195     self.INTERFACES = INTERFACES
 196     self.INFO = INFO
 197
 198     # Repertoire de calcul Europlexus
 199     self.REPE   = REPE
 200     # Commande d'execution de Europlexus
 201     self.EXEC   = EXEC
 202
 203     if args.has_key('UNITE_COURBE'): self.UNITE_COURBE = args['UNITE_COURBE']
 204     else:                            self.UNITE_COURBE = None
 205
 206     if args.has_key('PAS_INST_COURBE'): self.PAS_INST_COURBE = args['PAS_INST_COURBE']
 207     else:                            self.PAS_INST_COURBE = None
 208
 209     if args.has_key('PAS_NBRE_COURBE'): self.PAS_NBRE_COURBE = args['PAS_NBRE_COURBE']
 210     else:                            self.PAS_NBRE_COURBE = None
 211
 212     if args.has_key('TABLE_COURBE'): self.TABLE_COURBE = args['TABLE_COURBE']
 213     else:                            self.TABLE_COURBE = None
 214     # Dictionnaire contenant le texte associé au fichier de commande Europlexus
 215     self.epx = {}
 216
 217     if debug: print 'pas nbre courbe = %s'%self.PAS_NBRE_COURBE
 218
 219     # Concept pour un nouveau maillage si on utilise RIGI_PARASOL ou
 220     # si on regroupe separement les mailles tria3 et quad4
 221     self.NEW_MA = None
 222
 223     # Nom des fichiers de Europlexus (commande et sorties)
 224     self.nom_fichiers = {'COMMANDE' : 'commandes.epx',
 225                          'MAILLAGE' : 'maillage_epx',
 226                          'ALIT'     : 'champ.alit',
 227                          'MED'      : 'champ.e2m',
 228                          'PUN'      : 'courbes.pun',
 229                         }
 230
 231     # Chemin du repertoire courant ou le calcul Aster est lance
 232     self.pwd = os.getcwd() + os.sep
 233
 234
 235
 236 #-----------------------------------------------------------------------
 237   def get_unite_libre(self,):
 238
 239     _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
 240     unite=_UL['UNITE_LIBRE',1]
 241     DETRUIRE(CONCEPT=(_F(NOM=_UL),), INFO=1)
 242     return(unite)
 243
 244
 245 #-----------------------------------------------------------------------
 246   def reupere_structure(self,concept,mot_cle=None):
 247
 248     try : structure = concept.etape.valeur
 249     except : UTMESS('F','PLEXUS_1')
 250
 251     if mot_cle :
 252       if structure.has_key(mot_cle) : return structure[mot_cle]
 253       else : return None
 254     return structure
 255 #-----------------------------------------------------------------------
 256   def get_motcle(self,fact,mot_cle,code_mess='F'):
 257     try :
 258       out = fact[mot_cle]
 259     except :
 260       out = None
 261     if not out is None : return out
 262     if not code_mess is None and code_mess: UTMESS(code_mess,'PLEXUS_2',valk=mot_cle)
 263     return None
 264
 265 #-----------------------------------------------------------------------
 266   def get_group_ma(self,fact):
 267     group_ma = self.get_motcle(fact,'GROUP_MA',code_mess='F')
 268     if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,)
 269     # elif types.TypeType(group_ma) == types.ListType   : group_ma = tupel(group_ma)
 270     return group_ma
 271
 272 #-----------------------------------------------------------------------
 273   def get_group_ma_f(self,fact):
 274     group_ma = self.get_motcle(fact,'GROUP_MA',None)
 275     if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,)
 276     # elif types.TypeType(group_ma) == types.ListType   : group_ma = tupel(group_ma)
 277     if not group_ma : group_ma=[]
 278     return group_ma
 279
 280 #-----------------------------------------------------------------------
 281   def setlist(self,fact):
 282     #print 'types.TypeType(fact)',types.TypeType(fact)
 283     if fact is None : return fact
 284     #if not types.TypeType(fact) in [types.ListType,types.TupleType] : fact= [fact]
 285     if not (isinstance(fact,types.ListType) or isinstance(fact,types.TupleType))  : fact= [fact]
 286     return fact
 287
 288 #-----------------------------------------------------------------------
 289   def lire_fichier(self,fichier,):
 290     fd = open(fichier,'r')
 291     lignes = fd.readlines()
 292     fd.close()
 293     valeurs = []
 294     commentaires = ['#','%','$','*']
 295     for ll in lignes:
 296       add = 1
 297       for comment in commentaires :
 298         if string.find(ll,comment) != -1 : add = 0;break
 299       if add :
 300          data = [val for val in ll.split(None)]
 301          valeurs.append(data)
 302     return valeurs
 303
 304 #-----------------------------------------------------------------------
 305   def fichier2dic(self,fichier):
 306     valeurs = self.lire_fichier(fichier)
 307     dic = {}
 308     mot_cle = None
 309     for ll in valeurs:
 310       if len(ll) > 1 :
 311         for mot in ll :
 312           try :
 313             val = float(mot)
 314             if not mot_cle is None : dic[mot_cle].append(val)
 315           except :
 316             mot_cle = mot
 317             dic[mot_cle] = []
 318
 319     return dic
 320
 321 #-----------------------------------------------------------------------
 322   def lire_pun(self,fichier):
 323     if debug: print 'lire_pun : fichier = %s'%fichier
 324     data  = self.lire_fichier(fichier)
 325     icourbe = 0
 326     courbes = {}
 327     for ligne in data:
 328       if debug: print 'lire_pun : %s'%ligne
 329       if ligne[0] in ('VALEURS','VALUES'):
 330          icourbe += 1;
 331          nb = int(ligne[1])
 332          courbes[icourbe] = []
 333       else:
 334         ligne_vale = [float(val) for val in ligne]
 335         courbes[icourbe].append(ligne_vale)
 336     for courbe in courbes :
 337         courbes[courbe]=N.transpose(N.array(courbes[courbe]))
 338     return courbes
 339
 340 #-----------------------------------------------------------------------
 341   def export_DEBUT(self):
 342
 343     epx = self.epx
 344
 345     # Cle identifiant
 346     MODULE = 'DEBUT'
 347
 348     # Entete de la commande Europlexus courante
 349     epx[MODULE] = ['*--FICHIER CREE PAR CALC_EUROPLEXUS/Code_Aster']
 350
 351     # Texte declarant le debut
 352     epx[MODULE].append('TITRE')
 353     epx[MODULE].append('ECHO')
 354     options = 'TRID NONL'
 355 # AA    champ_fact = self.ECRITURE['CHAMP']
 356     champ_fact = self.ARCHIVAGE
 357     if champ_fact is not None : options += ' MEDE'
 358     epx[MODULE].append(options)
 359     epx[MODULE].append('\n')
 360
 361     # __temp
 362     fichier_cast2000 = 'fort.%i' %unite_cast2000
 363     if unite_cast2000 and os.path.isfile(fichier_cast2000) :
 364       sorite_cast2000 = self.pwd + 'REPE_OUT/post.k2000'
 365       epx[MODULE].append('OPNF 12')
 366       epx[MODULE].append(2*' ' + "'%s'" %sorite_cast2000)
 367       epx[MODULE].append('\n')
 368
 369 #-----------------------------------------------------------------------
 370   def export_MAILLAGE(self,format='CASTEM'):
 371
 372     epx = self.epx
 373
 374     # Cle identifiant
 375     MODULE = 'MAILLAGE'
 376
 377     # Entete de la commande Europlexus courante
 378     epx[MODULE] = ['*--LECTURE MAILLAGE']
 379
 380     # Recuperer la concept maillage modifie ou initial
 381     if self.NEW_MA is None :
 382       concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
 383     else :
 384       concept_maillage = copy.copy(self.NEW_MA)
 385
 386     # Ecrire le maillage, qui peut etre a ete enrichi avec des commandes Aster, sous le format souhaite (MED ou CASTEM)
 387     unite = self.get_unite_libre()
 388
 389     # Extensions des formats de maillage
 390     extension = {'CASTEM' : '.mgib', 'MED':'.med'}
 391
 392     # donner un nom au fichier de maillage parce que le fort.unite peut etre ecrase par d'autre operation d'ecriture
 393     nom_fichier = self.REPE + os.sep + self.nom_fichiers['MAILLAGE'] + extension[format]
 394     DEFI_FICHIER(UNITE=unite,FICHIER=nom_fichier,ACTION='ASSOCIER')
 395     IMPR_RESU(UNITE=unite,
 396               FORMAT=format,
 397               RESU = _F(MAILLAGE=concept_maillage)
 398              )
 399     DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');
 400
 401     # Ecriture de la commande Europlexus associee
 402     fichier_maillage = self.pwd + nom_fichier
 403
 404     #epx[MODULE].append('OPNF FORMAT 9')
 405     epx[MODULE].append('%s '%format)
 406     epx[MODULE].append("'%s' TOUT" %fichier_maillage)
 407     #epx[MODULE].append('CASTEM 9 TOUT')
 408
 409     epx[MODULE].append('\n')
 410
 411 #-----------------------------------------------------------------------
 412   def export_DIME(self,):
 413     epx = self.epx
 414
 415     # Cle identifiant
 416     MODULE = 'DIME'
 417
 418     # Entete de la commande Europlexus courante
 419     epx[MODULE] = ['*--DIMENSIONNEMENT']
 420     epx[MODULE].append('\n')
 421
 422     # Test si des parametres de dime seront introuduites à l'aide d'un fichier externe
 423     try    : unite_dime = self.DIME['UNITE_DIME']
 424     except : unite_dime = None
 425
 426     # Recuperer le dictionnaire issu du fichier associe à UNITE_DIME (s'il existe)
 427     if unite_dime is not None :
 428       fort = 'fort.%i' %unite_dime
 429       dic_fichier = self.fichier2dic(fort)
 430     else:
 431       dic_fichier = {}
 432
 433     # mettre a jour les cles definis dans le fichier par celles qui sont
 434     # definies directement sous le mot-cle facteur DIME
 435     cles = ['Q4GS', 'FORCE', 'PT6L', 'ZONE', 'POUT',
 436             'ECRO', 'APPU', 'BLOQ', 'PRESS', 'PMAT',
 437             'FTAB', 'DKT3', 'DEPL', 'FNOM', 'TABLE',
 438             'LIAI', 'MTTI', 'PT1L','NEPE']
 439
 440     for cle in cles:
 441       try:
 442         if self.DIME[cle] is not None :
 443           dic_fichier[cle] = self.DIME[cle]
 444       except : pass
 445
 446     # Imprimer les mot-cles et leurs dans epx
 447     epx[MODULE].append('DIME')
 448     for cle in dic_fichier:
 449       vale = dic_fichier[cle]
 450       st = 5*' ' + cle
 451       for v in vale:
 452         st += ' %i' %v
 453       epx[MODULE].append(st)
 454     epx[MODULE].append('TERM')
 455
 456     epx[MODULE].append('\n')
 457
 458 #-----------------------------------------------------------------------
 459   def export_MODELE(self):
 460
 461     epx = self.epx
 462
 463     # Cle identifiant
 464     MODULE = 'MODELE'
 465
 466     epx[MODULE] = ['*--DEFINITION DE LA GEOMETRIE']
 467
 468     # Entete de la commande Europlexus courante
 469     epx[MODULE].append('GEOMETRIE')
 470
 471     # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MODELE
 472     affe_modele = self.reupere_structure(self.MODELE,'AFFE')
 473     affe_modele = self.setlist(affe_modele)
 474
 475
 476     # Correspondance de modelisation aster/europlexus
 477     dic_modele = {'DKT':'DKT3','DKTG':'Q4GS','POU_D_E':'POUT'}
 478
 479     # Correspondance de modelisation europlexus/aster
 480     dic_modele_epx = {}
 481     for cle in dic_modele.keys():
 482       dic_modele_epx[dic_modele[cle]] = cle
 483
 484     # initialisation du dictioannaire qui contient les group_ma en fonction de la modelisation
 485     dic_gma = {}
 486     for cle in dic_modele.values():
 487       dic_gma[cle] = []
 488
 489     for affe in affe_modele:
 490       modelisation = affe['MODELISATION']
 491       phenomene = affe['PHENOMENE']
 492       if  phenomene == 'MECANIQUE' and modelisation in dic_modele.keys():
 493         if affe.has_key('GROUP_MA') :
 494           group_ma = self.get_group_ma(affe)
 495           dic_gma[dic_modele[modelisation]].extend(group_ma)
 496         else :
 497           UTMESS('F','PLEXUS_3')
 498
 499     # Regrouper separement les mailles tria3 et quad4 de la modilisation DKT (s'il y a lieu)
 500     # parce que leurs modilisations dans europlexus sont differentes:
 501     #                                                                tria3 : DKT3
 502     #                                                                quad4 : Q4GS
 503
 504     # Initialisation du dictionnaire contenant les elements du modele de type TRIA3 et QUAD4
 505     nom_groups= {'TRIA3':[],'QUAD4':[]}
 506
 507     if len(dic_gma['DKT3']) > 0:
 508       concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
 509       class_dkt = DKT(MAILLAGE=concept_maillage,)
 510       nom_groups = class_dkt.aster2epx(groups=dic_gma['DKT3'])
 511       if debug: print 'nom_groups = %s'%nom_groups
 512       # mettre a jour les groups de chaque modelisation
 513       dic_gma['DKT3'] = nom_groups['TRIA3']
 514       dic_gma['Q4GS'].extend(nom_groups['QUAD4'])
 515
 516
 517     # liste comportant les modelisations definis dans le module GEOMETRIE
 518     # cette liste va servir à determiner les indices des champs stockes dans le fichier med (get_resu)
 519     self.modelisations = []
 520     # Ecriture sous format europlexus
 521     for modelisation in  dic_gma.keys() :
 522       len_groups = len(dic_gma[modelisation])
 523       if len_groups > 0 :
 524         self.modelisations.append(modelisation)
 525         epx[MODULE].append(5*' ' + modelisation + 2*' ' + dic_gma[modelisation][0])
 526         if len_groups > 1 :
 527           for ig in range(1,len_groups) :
 528             group_ma = dic_gma[modelisation][ig]
 529             epx[MODULE].append((len(modelisation)+5+2)*' ' + group_ma)
 530
 531
 532
 533     # Mettre a jour le modele dans le cas ou le maillage a ete modifie pour la seperation de TRIA3 et QUAD4
 534     # ce modele va etre utilise dans la lecture du fichier med (get_resu)
 535     if len(nom_groups['QUAD4']) == 0 :
 536       self.NEW_MODELE = copy.copy(self.MODELE)
 537     else :
 538       affe_model = []
 539       for modelisation in self.modelisations :
 540          affe_model.append({'GROUP_MA':dic_gma[modelisation],
 541                            'MODELISATION': dic_modele_epx[modelisation],
 542                            'PHENOMENE':'MECANIQUE' })
 543
 544       __MO = AFFE_MODELE(MAILLAGE = concept_maillage,
 545                           AFFE = affe_model,
 546                           );
 547
 548       self.NEW_MODELE = copy.copy(__MO);
 549
 550     # Utiliser dans Ecriture des elements et points du fichier med
 551     self.dic_gma = dic_gma
 552     # Il y a une suite dans RIGI_PARSOL
 553
 554     #epx[MODULE].append('TERM')
 555     #epx[MODULE].append('\n')
 556
 557
 558  #-----------------------------------------------------------------------
 559   def export_CARA_ELEM(self):
 560
 561     epx = self.epx
 562
 563     # Cle identifiant
 564     MODULE = 'CARA_ELEM'
 565
 566     # Recuperer la structure du concept sorti de AFFE_CARA_ELEM
 567     cara_elem_struc = self.reupere_structure(self.CARA_ELEM)
 568
 569     epx[MODULE] = ['*--CARACTERISTIQUES DES ELEMENTS DE STRUCTURE']
 570
 571     # Entete de la commande Europlexus courante
 572     epx[MODULE].append('COMPLEMENT')
 573
 574     # Dictionnaire conteant les donnees associees aux differents elements de structure
 575     dic_elem = {}
 576     for cle in ['DISCRET','COQUE','POUTRE','RIGI_PARASOL']:
 577       if cara_elem_struc.has_key(cle):
 578         fact = cara_elem_struc[cle]
 579         if fact :
 580           dic_elem[cle] = self.setlist(fact)
 581
 582     # traduire les masses concentrees si elles existent
 583     cle = 'DISCRET'
 584     self.discretParasol = {}
 585     if dic_elem.has_key(cle):
 586       epx[MODULE].append('\n')
 587       epx[MODULE].append('*--MASSES AJOUTEES')
 588       for elem in dic_elem[cle]:
 589         if elem['CARA'] == 'M_T_D_N' :
 590           group_ma = self.get_group_ma(elem)
 591           vale = elem['VALE']
 592           epx[MODULE].append('MASSE  123456 %s' %vale)
 593           epx[MODULE].append(7*' ' + 'LECT')
 594           for group in group_ma:
 595             epx[MODULE].append(11*' '+group)
 596           epx[MODULE].append(7*' ' + 'TERM')
 597         if elem['CARA'] == 'K_TR_D_N' :
 598           group_ma = self.get_group_ma(elem)
 599           vale     = elem['VALE']
 600           for gma in group_ma :
 601             self.discretParasol[gma] = vale
 602
 603     # traduire les elements coques s'ils existent
 604     cle = 'COQUE'
 605     self.dicOrthotropie={}
 606     self.listEpais=[]
 607     self.listEpais2=[]
 608     if dic_elem.has_key(cle):
 609       epx[MODULE].append('\n')
 610       epx[MODULE].append('*--ELEMENTS COQUES')
 611       for elem in dic_elem[cle]:
 612 #        print elem
 613         group_ma = self.get_group_ma(elem)
 614         epais = elem['EPAIS']
 615         if self.ARCHIVAGE['CONT_GENER'] == 'OUI' :
 616             self.listEpais.append({'VALE' : epais, 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'})
 617             self.listEpais2.append({'VALE' : epais**2/6., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'})
 618         else :
 619             self.listEpais.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'})
 620             self.listEpais2.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'})
 621         st = 'EPAIS  %s  ' %epais
 622         #ajouter les group_ma qui ont ete affecte par ces caracteristiques
 623         epx[MODULE].append(st+'LECT')
 624         for group in group_ma:
 625           epx[MODULE].append((len(st)+4)*' '+group)
 626         epx[MODULE].append((len(st))*' '+'TERM')
 627         if elem.has_key('VECTEUR'):
 628 # AA       if elem['VECTEUR'] :
 629             for group in group_ma :
 630                 self.dicOrthotropie[group] = elem['VECTEUR']
 631
 632     # traduire les elements poutres s'ils existent
 633     cle = 'POUTRE'
 634     if dic_elem.has_key(cle):
 635       concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
 636       #class permettant de calculer et verifier les vecteurs de poutre dans Europlexus
 637       class_poutre = POUTRE(MAILLAGE=concept_maillage,CARA_ELEM=self.CARA_ELEM)
 638       epx[MODULE].append('\n')
 639       epx[MODULE].append('*--ELEMENTS POUTRES')
 640       for elem in dic_elem[cle]:
 641         group_ma = self.get_group_ma(elem)
 642         vecteurs = class_poutre.getvecteurs(group_ma,verif='non')
 643         vect_y = vecteurs[group_ma[0]]
 644         type_section = elem['SECTION']
 645         st = 'GEOP %s ' %type_section
 646         if type_section == 'RECTANGLE' :
 647           # Correspondance de caracteristique de poutre aster/europlexus
 648           dic_corresp = {'HY':'AY','HZ':'AZ'}
 649           epx[MODULE].append(st)
 650           # ajouter le vecteur definisant l'orientation de la section
 651           epx[MODULE].append(len(st)*' ' + 'VX %s' %vect_y[0])
 652           epx[MODULE].append(len(st)*' ' + 'VY %s' %vect_y[1])
 653           epx[MODULE].append(len(st)*' ' + 'VZ %s' %vect_y[2])
 654           # ajouter les caracteristiques de la poutre
 655           cara = elem['CARA']
 656           vale = elem['VALE']
 657           for icar in range(len(cara)):
 658             car = cara[icar]
 659             val = vale[icar]
 660             car_epx = dic_corresp[car]
 661             epx[MODULE].append(len(st)*' ' + '%s %s' %(car_epx,val))
 662           # ajouter les group_ma qui ont ete affecte par ces caracteristiques
 663           epx[MODULE].append(5*' '+'LECT')
 664           for group in group_ma:
 665             epx[MODULE].append(len(st)*' '+group)
 666           epx[MODULE].append(5*' '+'TERM')
 667         else :
 668           UTMESS('A','PLEXUS_4',valk=type_section)
 669
 670     epx[MODULE].append('\n')
 671
 672 #-----------------------------------------------------------------------
 673   def export_RIGI_PARASOL(self):
 674
 675     epx = self.epx
 676
 677     # Cle identifiant
 678     MODULE = 'RIGI_PARASOL'
 679     concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
 680     self.MApyt = MAIL_PY()
 681     self.MApyt.FromAster(concept_maillage)
 682
 683     # Recuperer la structure du concept sorti de AFFE_CARA_ELEM
 684     cara_elem_struc = self.reupere_structure(self.CARA_ELEM)
 685
 686     # Recuperer la structure RIGI_PARASOL si elles existe
 687     list_rigi_parasol = None
 688     if cara_elem_struc.has_key('RIGI_PARASOL'):
 689       fact = cara_elem_struc['RIGI_PARASOL']
 690       if fact :list_rigi_parasol = self.setlist(fact)
 691
 692     # Traduction des fonctions definies dans FONC_PARASOL
 693     #dic_fonc_parasol = self.get_FONC_PARASOL(list_rigi_parasol)
 694     dic_fonc_parasol = self.get_FONC_PARASOL()
 695 #    if not dic_fonc_parasol: return
 696
 697     epx[MODULE] = ['*--SUPPORT ELASTIQUE']
 698
 699     # si l'utilisateur a lui meme fourni des GROUP_MA de discrets : on commence par la
 700     gmaParasol=self.get_group_ma_f(self.FONC_PARASOL)
 701     group_union = ''
 702     for gma in gmaParasol :
 703         if gma not in self.discretParasol :
 704             if debug: print gma
 705             if debug: print self.discretParasol.keys()
 706             raise 'Discret non defini'
 707         vale = self.discretParasol[gma]
 708         epx[MODULE].append('SUPPORT')
 709         epx[MODULE].append(6*' '+'KX %s  KY %s  KZ %s'%(vale[0],vale[1],vale[2]))
 710         epx[MODULE].append(6*' '+'KRX %s KRY %s KRZ %s'%(vale[3],vale[4],vale[5]))
 711         for cle_fonc_parasol in dic_fonc_parasol.keys() :
 712           epx[MODULE].append(6*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) )
 713         epx[MODULE].append(6*' '+'LECT %s TERM'% gma)
 714         group_union += '%s '% gma
 715     if len(gmaParasol) > 0 :
 716         epx['MODELE'].append(5*' ' + 'APPU  ' + group_union)
 717
 718     # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
 719     # DEFI_GROUP(reuse         = concept_maillage,
 720                  # MAILLAGE      = concept_maillage,
 721                  # CREA_GROUP_NO = _F(GROUP_MA = gmaParasol),
 722                 # );
 723
 724
 725
 726     # traduire les rigi_parasol
 727 # AA    if list_rigi_parasol :
 728     if list_rigi_parasol and dic_fonc_parasol:
 729       # changement de module parce que les supports issus de RIGI_PARASOL  doivent etre imprimes apres les materiaux
 730       # fichiers_parasol = []
 731       # cles_oblig = ['UNITE_EUROPLEXUS','GROUP_MA_POI1']
 732       # for elem in list_rigi_parasol:
 733         # elem_cara = elem['CARA']
 734         # if elem_cara == 'K_TR_D_N':
 735           # for cle_test in cles_oblig:
 736             # if not elem.has_key(cle_test):
 737               # pass
 738           # unite = elem['UNITE_EUROPLEXUS']
 739           # fichier = 'fort.%i' %unite
 740           # if fichier not in fichiers_parasol : fichiers_parasol.append(fichier)
 741         # else :
 742         #   pass
 743       # Lecture des valeurs de rigidites generees par aster a partir des rigidites globales definis dans PARA_RIGISOL
 744       # ressorts = []
 745       # for fichier in fichiers_parasol :
 746         # ressorts.extend(self.lire_fichier(fichier))
 747       ressorts = self.CARA_ELEM.toEPX()
 748       # Creer un maillage qui, pour chaque noeud de l'interface utilisee dans rigi_parsol, asscocie un group_ma asscie
 749       # parce que on n'a pas les memes numeros des noeuds dans Europlexus
 750       crea_poi1 = []
 751       dic_gma = {}
 752       igr = -1
 753       # Liste des group_ma associes au noeuds ou le RIGI_PARSOL a ete applique
 754       groups_parasol = []
 755
 756       for noeud in ressorts.keys() :
 757         # noeud = ressor[0]
 758         if not dic_gma.has_key(noeud):
 759           igr += 1
 760           group_ma = 'SUP%i' %igr
 761           dic_gma[noeud] = group_ma
 762           groups_parasol.append(group_ma)
 763           crea_poi1.append(_F(NOEUD=noeud,NOM_GROUP_MA=group_ma))
 764
 765       # ATTENTION : a deplacer
 766       # crea_maillage a faire de facon centraliser pour RIGI_PARASOL et le POST-TRAITEMENT ailleurs
 767       courbe_fact = self.COURBE
 768       if courbe_fact is None: courbe_fact = []
 769       lnoeuds=sets.Set([])
 770       lmailles=sets.Set([])
 771       dicma=[]
 772       for courbe in courbe_fact :
 773         if courbe['GROUP_NO'] != None :
 774             noeuds = courbe['GROUP_NO']
 775             if type(noeuds) == tuple :
 776                 for el in noeuds :
 777                     lnoeuds.add(el)
 778             else :
 779                 lnoeuds.add(noeuds)
 780         if courbe['GROUP_MA'] != None :
 781             mailles = courbe['GROUP_MA']
 782             if type(mailles) == tuple :
 783                 for el in mailles :
 784                     lmailles.add(el)
 785             else :
 786                 lmailles.add(mailles)
 787       for maille in lmailles :
 788         dicma.append({'NOM' : maille, 'MAILLE' : maille})
 789
 790       for no in lnoeuds :
 791         if not self.MApyt.gno.has_key(no) :
 792             crea_poi1.append(_F(NOEUD=no,NOM_GROUP_MA=no))
 793
 794       __NEW = CREA_MAILLAGE(MAILLAGE=concept_maillage,
 795                              CREA_POI1 = crea_poi1,
 796                             );
 797       self.NEW_MA = copy.copy(__NEW)
 798
 799       # Ecriture sous format europlexus
 800       # Indices des composantes
 801       indices_comps = {'KX':1,'KY':2,'KZ':3,'KRX':4,'KRY':5,'KRZ':6}
 802       for noeud in ressorts :
 803         valeurs = ressorts[noeud]
 804         epx[MODULE].append('SUPPORT')
 805         # ecriture des composantes et de leurs valeurs associees
 806         for comp in indices_comps.keys():
 807           if debug: print len(valeurs),indices_comps[comp]-1
 808           vale = valeurs[indices_comps[comp]-1]
 809           epx[MODULE].append(3*' ' + '%s %s' %(comp,vale))
 810         # caracteristiques des translations et des rotations
 811         for cle_fonc_parasol in dic_fonc_parasol.keys() :
 812           epx[MODULE].append(3*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) )
 813
 814         # ecriture du group_ma associe
 815         # noeud = ressor[0]
 816         group_ma = dic_gma[noeud]
 817         epx[MODULE].append(3*' ' + 'LECT %s TERM' % group_ma)
 818
 819       epx[MODULE].append('\n')
 820
 821       group_union = 'PARASOL'
 822       dicma.append({'NOM' : group_union, 'UNION' : groups_parasol})
 823       __NEW = DEFI_GROUP(reuse = __NEW,
 824                 MAILLAGE = __NEW,
 825                 CREA_GROUP_MA = dicma
 826                 )
 827
 828       # Mettre a jour le module modele qd les ressorts existent
 829       epx['MODELE'].append(5*' ' + 'APPU  ' + group_union)
 830
 831     # Fermer le module modele dans tous les cas
 832     self.multidomaine = 0
 833     listInterfaces = self.INTERFACES
 834     self.gmaInterfaces=[]
 835     if listInterfaces :
 836         i=0
 837         self.multidomaine = 1
 838         for interface in listInterfaces :
 839             Lgma1 = self.setlist(interface['GROUP_MA_1'])
 840             Lgma2 = self.setlist(interface['GROUP_MA_2'])
 841             self.gmaInterfaces.extend(Lgma1)
 842             self.gmaInterfaces.extend(Lgma2)
 843             for gma in Lgma1 :
 844                 if i==0 :
 845                     epx['MODELE'].append(5*' ' + 'CL3L' + 2*' ' + gma)
 846                 else :
 847                     epx['MODELE'].append(11*' ' + gma)
 848             for gma in Lgma2 :
 849                     epx['MODELE'].append(11*' ' + gma)
 850             i+=1
 851     epx['MODELE'].append('TERM')
 852     epx['MODELE'].append('\n')
 853
 854     if self.gmaInterfaces :
 855         epx['CHAM_MATER'].append('FANTOME 0. LECT')
 856         for gma in self.gmaInterfaces :
 857             epx['CHAM_MATER'].append(15*' '+'%s'% gma)
 858         epx['CHAM_MATER'].append('           TERM')
 859     epx['CHAM_MATER'].append('\n')
 860
 861
 862     # DEFINITION REPERES ORTHOTROPIE QUI DOIT ETRE APRES LES SUPPORTS
 863     for gma in self.gmaGLRC :
 864         if gma not in self.dicOrthotropie :
 865             raise "Erreur : %s non affecte par un repere d'orthotropie : ajouter le mot-cle 'VECTEUR' dans AFFE_CARA_ELEM"% gma
 866         vale = self.dicOrthotropie[gma]
 867         epx[MODULE].append('COMP ORTS %s %s %s'%(vale[0],vale[1],vale[2]))
 868         epx[MODULE].append(3*' '+'LECT')
 869         epx[MODULE].append(7*' '+'%s'% gma)
 870         epx[MODULE].append(3*' '+'TERM')
 871
 872     epx[MODULE].append('\n')
 873
 874 #-----------------------------------------------------------------------
 875   def get_FONC_PARASOL(self,list_rigi_parasol=None) :
 876
 877     epx = self.epx
 878
 879     MODULE = 'FONC_PARASOL'
 880     if list_rigi_parasol is not None :
 881       if self.FONC_PARASOL is None : UTMESS('F','PLEXUS_12')
 882     # else : return None
 883
 884     epx[MODULE] = ['*--DEFINITIONS DES FONCTIONS']
 885
 886     # Entete de la commande europlexus
 887     epx[MODULE].append('FONC')
 888
 889     # Cles de FONC_PARASOL dans l'ordre
 890     cles = ['NFKT','NFKR']
 891     # Dictionnaire faisant la correspondance entre la fonction et son numero europlexus
 892     dic_fonc = {}
 893     try :
 894         ifonc = self.ifonc
 895         if debug: print 'self.ifonc = %s'%ifonc
 896     except :
 897         self.ifonc=0
 898         ifonc = self.ifonc
 899         if debug: print 'ifonc = %s'%ifonc
 900     if epx.has_key('FONC_MATER') :
 901         epx[MODULE].extend(epx['FONC_MATER'])
 902     for cle in cles:
 903       ifonc += 1
 904       dic_fonc[cle] = ifonc
 905       fonction = self.get_motcle(self.FONC_PARASOL,cle,code_mess=None)
 906       if not fonction: return {}    # Si les mots-cles sont manquants on passe
 907       (temps,valeurs) = fonction.Valeurs()
 908       # imprimer les valeurs de la table
 909       epx[MODULE].append(5*' ' +'NOPA %i TABLE %i' %(ifonc,len(temps)) )
 910       for ival in range(len(temps)):
 911 #         epx[MODULE].append(17*' ' +'%s %s' %(temps[ival],valeurs[ival]))
 912          epx[MODULE].append(17*' ' +'%s %s' %(temps[ival],valeurs[ival]))
 913     self.ifonc = ifonc
 914     self.dic_fonc = dic_fonc
 915     epx[MODULE].append('\n')
 916     return dic_fonc
 917
 918 #-----------------------------------------------------------------------
 919   def export_CHAM_MATER(self):
 920
 921     epx = self.epx
 922
 923     # CLe identifiant
 924     MODULE = 'CHAM_MATER'
 925
 926     epx[MODULE] = ['*--DEFINITION DES MATERIAUX']
 927
 928     # Entete de la commande Europlexus courante
 929     epx[MODULE].append('MATERIAUX')
 930
 931     # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MATER
 932     affe_mater = self.reupere_structure(self.CHAM_MATER,'AFFE')
 933     affe_mater = self.setlist(affe_mater)
 934
 935     # Dictionnaire stoquant les caracteristiques mecaniques et les group_ma associe a chaque materiau
 936     dic_mater = {}
 937     typMat = {}
 938     # 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
 939     self.gmaGLRC = []
 940     epx['FONC_MATER'] = []
 941     ref_fonc=[]
 942     for affe in affe_mater :
 943       # Recuperer le concept du materiau defini par DEFI_MATERIAU
 944       concept_mater = affe['MATER']
 945       # Recuperer le nom du materiau
 946       nom_mater = concept_mater.get_name()
 947       # Recuperer le group_ma concerne
 948       group_ma = self.get_group_ma(affe)
 949       if debug: print 'type(group_ma) = %s'%type(group_ma)
 950       if not dic_mater.has_key(nom_mater):
 951          dic_mater[nom_mater] = {'GROUP_MA':[]}
 952          # Recuperer les caracteristiques elastiques du materiau
 953          elas = self.reupere_structure(concept_mater,'ELAS')
 954          if elas :
 955             typMat[nom_mater] = 'ELAS'
 956             for car in ['E','RHO','NU']:
 957               dic_mater[nom_mater][car] = elas[car]
 958             for car in ['AMOR_ALPHA','AMOR_BETA'] :
 959               if elas.has_key(car) :
 960                 dic_mater[nom_mater][car] = elas[car]
 961               else :
 962                 dic_mater[nom_mater][car] = None
 963          beton = self.reupere_structure(concept_mater,'BETON')
 964          if beton  :
 965             typMat[nom_mater] = 'GLRC'
 966             self.gmaGLRC.extend(group_ma)
 967             dic_mater[nom_mater]['LINER']=[]
 968             dic_mater[nom_mater]['NAPPE']=[]
 969             materBeton = beton['MATER']
 970             elasBeton = self.reupere_structure(materBeton,'ELAS')
 971             dic_mater[nom_mater]['BETON']={}
 972             for car in ['E','RHO','NU']:
 973               dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car)
 974             for car in ['AMOR_ALPHA','AMOR_BETA']:
 975               dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car,None)
 976             ecroBeton = self.reupere_structure(materBeton,'BETON_ECRO_LINE')
 977             for car in ['SYT','SYC']:
 978               dic_mater[nom_mater]['BETON'][car] = self.get_motcle(ecroBeton,car,None)
 979             for car in ['EPAIS','GAMMA','QP1','QP2','C1N1','C1N2','C1N3','C2N1','C2N2','C2N3','C1M1','C1M2','C1M3','C2M1','C2M2','C2M3'] :
 980               dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car)
 981             for car in ['OMT','EAT','BT1','BT2'] :
 982               dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car,None)
 983             for car in ['MP1X','MP1Y','MP2X','MP2Y'] :
 984               car_temp = self.get_motcle(beton,car,None)
 985               if debug: print 'type(car_temp) = %s'%type(car_temp)
 986               dic_mater[nom_mater]['BETON'][car] = None
 987               if car_temp :
 988                   if type(car_temp) == float :
 989                     dic_mater[nom_mater]['BETON'][car] = car_temp
 990                   else :
 991                     if debug: print dir(car_temp)
 992                     try :
 993                         ifonc = self.ifonc
 994                     except :
 995                         self.ifonc=0
 996                         ifonc = self.ifonc
 997                     ifonc += 1
 998                     val = car_temp.Valeurs()
 999                     x = val[:len(val):2]
1000                     y = val[1:len(val):2]
1001                     # imprimer les valeurs de la table
1002                     epx['FONC_MATER'].append(5*' ' +'%i LSQU 2 TABLE %i' %(ifonc,len(x)) )
1003                     for ival in range(len(x)):
1004 #                       epx['FONC_MATER'].append(17*' ' +'%s %s' %(x[ival],y[ival]))
1005                        epx['FONC_MATER'].append(17*' ' +'%s %s' %(x[ival],y[ival]))
1006                     dic_mater[nom_mater]['BETON'][car] = 'FONC %i'%ifonc
1007                     self.ifonc=ifonc
1008
1009
1010          cable = self.reupere_structure(concept_mater,'CABLE_PREC')
1011          if cable  :
1012             materCable = cable['MATER']
1013             elasCable = self.reupere_structure(materCable,'ELAS')
1014             ecroCable = self.reupere_structure(materCable,'ECRO_LINE')
1015             dic_mater[nom_mater]['CABLE']={}
1016             for car in ['E','NU']:
1017               dic_mater[nom_mater]['CABLE'][car] = elasCable[car]
1018             for car in ['SY']:
1019               dic_mater[nom_mater]['CABLE'][car] = ecroCable[car]
1020             for car in ['OMX','OMY','RX','RY','PREX','PREY'] :
1021               dic_mater[nom_mater]['CABLE'][car] = cable[car]
1022          Lnappes = self.setlist(self.reupere_structure(concept_mater,'NAPPE'))
1023          if Lnappes  :
1024             for nappe in Lnappes :
1025                 dic_tmp = {}
1026                 materNappe = nappe['MATER']
1027                 elasNappe = self.reupere_structure(materNappe,'ELAS')
1028                 ecroNappe = self.reupere_structure(materNappe,'ECRO_LINE')
1029                 for car in ['E','NU']:
1030                   dic_tmp[car] = elasNappe[car]
1031                 for car in ['SY']:
1032                   if ecroNappe :
1033                     dic_tmp[car] = ecroNappe[car]
1034                   else :
1035                     dic_tmp[car] = None
1036                 for car in ['OMX','OMY','RX','RY'] :
1037                   dic_tmp[car] = nappe[car]
1038                 for car in ['FS',] :
1039                   if nappe.has_key(car) :
1040                     dic_tmp[car] = nappe[car]
1041                   else :
1042                     dic_tmp[car] = None
1043                 dic_mater[nom_mater]['NAPPE'].append(dic_tmp)
1044          Lliners = self.setlist(self.reupere_structure(concept_mater,'LINER'))
1045          if Lliners :
1046             for liner in Lliners :
1047                 dic_tmp = {}
1048                 materLiner = liner['MATER']
1049                 elasLiner = self.reupere_structure(materLiner,'ELAS')
1050                 ecroLiner = self.reupere_structure(materLiner,'ECRO_LINE')
1051                 for car in ['E','NU']:
1052                   dic_tmp[car] = elasLiner[car]
1053                 for car in ['SY']:
1054                   dic_tmp[car] = ecroLiner[car]
1055                 for car in ['OML','RLR'] :
1056                   dic_tmp[car] = liner[car]
1057                 dic_mater[nom_mater]['LINER'].append(dic_tmp)
1058
1059
1060       if debug: print 'MATER = %s \n type = %s \n dic = %s'%(nom_mater,typMat, dic_mater[nom_mater])
1061       dic_mater[nom_mater]['GROUP_MA'].extend(group_ma)
1062
1063       # if gmaGLRC :
1064           # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
1065           # if debug: print 'ETAPES MAILLAGES'
1066           # if debug: print dir(concept_maillage)
1067           # if debug: print concept_maillage.executed
1068           # if debug: print concept_maillage.etape
1069           # if debug: print dir(concept_maillage.etape)
1070           # if debug: print concept_maillage.etape.get_liste_etapes()
1071           # if debug: print concept_maillage.etape.valeur
1072
1073
1074     # Impression au format Europlexus
1075
1076     for nom_mater in dic_mater.keys():
1077       epx[MODULE].append('*--MATERIAU %s' %nom_mater)
1078       # mot cle indicant qu'il s'agit des caracteristiques lineaires du materiau
1079       if typMat[nom_mater] == 'ELAS' :
1080           dic_corresp = {'E':'YOUNG','NU':'NU','RHO':'RO'}
1081           dic_corresp2 ={'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'}
1082           epx[MODULE].append('LINE')
1083           for car_aster in dic_corresp.keys():
1084             vale    = dic_mater[nom_mater][car_aster]
1085             car_epx = dic_corresp[car_aster]
1086             if vale is not None :
1087               epx[MODULE].append('%s %s' %(car_epx,vale))
1088           for car_aster in dic_corresp2.keys():
1089             vale    = dic_mater[nom_mater][car_aster]
1090             car_epx = dic_corresp2[car_aster]
1091             if vale is not None :
1092               epx[MODULE].append('%s %s' %(car_epx,vale))
1093       else : #GLRC
1094         dic_corres1 = {'RHO':'RO','EPAIS':'H','E':'EB','NU':'NUB'}
1095         dic_corresNapp = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY','FS':'FS'}
1096         dic_corresPrec = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY'}
1097         dic_corresLinr = {'E' : 'EA','SY':'FY','OML':'OMLR','NU':'NULR','RLR':'RLR'}
1098         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'}
1099         dic_corres2b = {'MP1X':'MP1X','MP2X':'MP2X','MP1Y':'MP1Y','MP2Y':'MP2Y',}
1100         dic_corres3 = {'PREX' : 'PREX', 'PREY' : 'PREY'}
1101         dic_corres4 = {'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'}
1102         epx[MODULE].append('GLRC DAMA')
1103         for car_aster in dic_corres1.keys():
1104             vale    = dic_mater[nom_mater]['BETON'][car_aster]
1105             car_epx = dic_corres1[car_aster]
1106             if vale is not None :
1107                 epx[MODULE].append('%s %s' %(car_epx,vale))
1108         nlit = len(dic_mater[nom_mater]['NAPPE'])+len(dic_mater[nom_mater]['LINER'])
1109         if dic_mater[nom_mater].has_key('CABLE') :
1110             nlit+=1
1111         if nlit :
1112             epx[MODULE].append('%s %s' %('NLIT',nlit))
1113         for nappe in dic_mater[nom_mater]['NAPPE'] :
1114             epx[MODULE].append('NAPP')
1115             for car_aster in dic_corresNapp.keys():
1116                 if nappe.has_key(car_aster) :
1117                     vale    = nappe[car_aster]
1118                     car_epx = dic_corresNapp[car_aster]
1119                     if vale is not None:
1120                         epx[MODULE].append('%s %s' %(car_epx,vale))
1121         if dic_mater[nom_mater].has_key('CABLE') :
1122             epx[MODULE].append('PREC')
1123             for car_aster in dic_corresPrec.keys():
1124                 vale    = dic_mater[nom_mater]['CABLE'][car_aster]
1125                 car_epx = dic_corresPrec[car_aster]
1126                 if vale is not None :
1127                     epx[MODULE].append('%s %s' %(car_epx,vale))
1128         for liner in dic_mater[nom_mater]['LINER'] :
1129             epx[MODULE].append('LINR')
1130             for car_aster in dic_corresLinr.keys():
1131                 vale    = liner[car_aster]
1132                 car_epx = dic_corresLinr[car_aster]
1133                 if vale is not None :
1134                     epx[MODULE].append('%s %s' %(car_epx,vale))
1135         for car_aster in dic_corres2.keys():
1136             vale    = dic_mater[nom_mater]['BETON'][car_aster]
1137             car_epx = dic_corres2[car_aster]
1138             if vale is not None :
1139                 if type(vale) == float :
1140                     epx[MODULE].append('%s %s' %(car_epx,vale))
1141                 else :
1142                     epx[MODULE].append('%s %s' %(car_epx,vale))
1143         for car_aster in dic_corres2b.keys():
1144             vale    = dic_mater[nom_mater]['BETON'][car_aster]
1145             car_epx = dic_corres2b[car_aster]
1146             if vale is not None :
1147                 if type(vale) == float :
1148                     epx[MODULE].append('%s %s' %(car_epx,vale))
1149                 else :
1150                     epx[MODULE].append('%s %s' %(car_epx,vale))
1151         if dic_mater[nom_mater].has_key('CABLE') :
1152             for car_aster in dic_corres3.keys():
1153                 vale    = dic_mater[nom_mater]['CABLE'][car_aster]
1154                 car_epx = dic_corres3[car_aster]
1155                 if vale is not None :
1156                     epx[MODULE].append('%s %s' %(car_epx,vale))
1157         for car_aster in dic_corres4.keys():
1158             vale    = dic_mater[nom_mater]['BETON'][car_aster]
1159             car_epx = dic_corres4[car_aster]
1160             if vale is not None :
1161                 epx[MODULE].append('%s %s' %(car_epx,vale))
1162
1163           # ajouter les group_ma qui ont ete affecte par ces caracteristiques
1164       epx[MODULE].append(3*' '+'LECT')
1165       for group in dic_mater[nom_mater]['GROUP_MA']:
1166         epx[MODULE].append(7*' '+group)
1167       epx[MODULE].append(3*' '+'TERM')
1168
1169
1170     return epx
1171
1172 #-----------------------------------------------------------------------
1173   def export_EXCIT(self):
1174
1175     epx = self.epx
1176
1177     # CLe identifiant
1178     MODULE = 'EXCIT'
1179
1180     epx[MODULE] = ['*--DEFINITION DES CHARGEMENTS et DES CONDITIONS AUX LIMITES']
1181
1182     # Entete de la commande Europlexus courante
1183     #epx[MODULE].append('CHARGEMENT')
1184
1185     try :
1186       test = self.EXCIT[0]
1187       excit_list = self.EXCIT
1188     except :
1189       excit_list = self.setlist(self.EXCIT)
1190
1191     #print '<INFO> excit_list = ',excit_list
1192     #print '<INFO> type(excit_list) = ', type(excit_list)
1193
1194     # Traduction de ddl_impo
1195     dic_ddl_impo = {'DX':1,'DY':2,'DZ':3,'DRZ':4,'DRY':5,'DRZ':6}
1196
1197     # Initialisation des variables decrivant le chargement et les conditions de blocage
1198     CHARGEMENT = []
1199     LIAISON   = []
1200
1201     for excit in excit_list:
1202       concept_charge = excit['CHARGE']
1203       pres_rep_list = self.reupere_structure(concept_charge,'PRES_REP')
1204       ddl_impo_list = self.reupere_structure(concept_charge,'DDL_IMPO')
1205       pres_rep_list = self.setlist(pres_rep_list)
1206       ddl_impo_list = self.setlist(ddl_impo_list)
1207       # PRES_REP
1208       if pres_rep_list :
1209         if len(CHARGEMENT) == 0 :
1210           CHARGEMENT = ['CHARGEMENT']
1211           CHARGEMENT.append(2*' ' + '1 FACTO 2')
1212         fonction = self.get_motcle(excit,'FONC_MULT',code_mess='A')
1213         if fonction is None:
1214           UTMESS('F','PLEXUS_7')
1215         (temps,valeurs) = fonction.Valeurs()
1216         for pres_rep in  pres_rep_list :
1217           pression = pres_rep['PRES']
1218           group_ma = self.get_group_ma(pres_rep)
1219           CHARGEMENT.append(6*' ' +'PRESS COQU %s' %pression)
1220           # ajouter les group_ma qui ont ete affecte par ces caracteristiques
1221           CHARGEMENT.append(6*' '+'LECT')
1222           for group in group_ma:
1223             CHARGEMENT.append(10*' '+group)
1224           CHARGEMENT.append(6*' '+'TERM')
1225           # imprimer les valeurs de la table
1226           CHARGEMENT.append(6*' ' +'TABLE %i' %len(temps))
1227           for ival in range(len(temps)):
1228             CHARGEMENT.append(10*' ' +'%s %s' %(temps[ival],valeurs[ival]))
1229       # DDL_IMPO
1230       #if debug: print 'ddl_impo_list',ddl_impo_list
1231       if ddl_impo_list :
1232         #UTMESS('A','PLEXUS_8')
1233 # AA        if len(LIAISON) == 0 : LIAISON = ['LIAISON']
1234         if len(LIAISON) == 0 : LIAISON = ['LINK']
1235
1236         for ddl_impo in ddl_impo_list:
1237           blocage = ''
1238
1239           # DDL_IMPO / DX
1240           for cle in dic_ddl_impo.keys() :
1241             vale = self.get_motcle(ddl_impo,cle,code_mess=None)
1242             if vale is not None:
1243               if vale != 0 : UTMESS('F','PLEXUS_13')
1244               else :
1245                 blocage += `dic_ddl_impo[cle]`
1246
1247           # LIAISON / ENCASTRE
1248           if ddl_impo.has_key('LIAISON'):
1249              if ddl_impo['LIAISON']=='ENCASTRE':
1250                 blocage += ' 123456'
1251
1252           # recupere les entites geometriques
1253           for entite in ['GROUP_MA','GROUP_NO'] :
1254             group_ma = self.get_motcle(ddl_impo,entite,code_mess=None)
1255             if group_ma is not None :
1256               group_ma = self.setlist(group_ma);break
1257           LIAISON.append(' '*2 + 'BLOQ %s' %blocage)
1258           # ajouter les group_ma qui ont ete affecte par ces caracteristiques
1259           LIAISON.append(6*' '+'LECT')
1260           for group in group_ma:
1261             LIAISON.append(10*' '+group)
1262           LIAISON.append(6*' '+'TERM')
1263
1264       if not ddl_impo_list and not pres_rep_list :
1265         UTMESS('F','PLEXUS_9')
1266
1267     # Transmettre les commandes a la liste global epx
1268     for var in [CHARGEMENT,LIAISON] :
1269       if len(var) > 0 :
1270         epx[MODULE].append('\n')
1271         for ligne in var : epx[MODULE].append(ligne)
1272
1273     epx[MODULE].append('\n')
1274 #-----------------------------------------------------------------------
1275   def Correspondance_champ(self):
1276
1277     # Dictionnaire de passage de champs Aster --> Europlexus
1278     dic_champ = {'DEPL':'DEPLACEMENT','VITE':'VITESSE','ACCE':'ACCELERATION',
1279                  'SIEF_ELGA':'CONT','EPSI_ELGA':'EPST','VARI_ELGA':'ECRO'}
1280
1281     # Dictionnaire de passage de composantes Aster --> Europlexus
1282     dic_cmp = {}
1283     for cham in ['DEPL','VITE','ACCE'] :
1284       dic_cmp[cham] = {'DX' : 1,'DY':2,'DZ':3,'DRX':4,'DRY':5,'DRZ':6}
1285
1286     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}
1287     dic_cmp['VARI_ELGA'] = {}
1288     for ii in range(1,25):
1289       dic_cmp['VARI_ELGA']['V%i'%ii] = ii
1290
1291     self.dic_champ = dic_champ
1292     self.dic_cmp = dic_cmp
1293
1294
1295 #-----------------------------------------------------------------------
1296   def export_ECRITURE(self):
1297
1298     epx = self.epx
1299
1300     self.Correspondance_champ()
1301
1302     # CLe identifiant
1303     MODULE = 'ECRITURE'
1304
1305     dcles_freq = {'FREQ':'PAS_NBRE', 'TFREQ':'PAS_INST'}
1306
1307     def get_freq(fact):
1308       for cle_freq in dcles_freq.keys():
1309 # AA        vale_freq = self.get_motcle(fact,cle_freq,code_mess=None)
1310         vale_freq = self.get_motcle(fact,dcles_freq[cle_freq],code_mess=None)
1311         if vale_freq is not None : break
1312       return cle_freq,vale_freq
1313
1314     def get_freq2() :
1315         if self.PAS_NBRE_COURBE :
1316             return 'FREQ',self.PAS_NBRE_COURBE
1317         elif self.PAS_INST_COURBE :
1318             return 'TFREQ',self.PAS_INST_COURBE
1319         else :
1320             raise 'Erreur programmation'
1321
1322
1323     def string2list(var) :
1324       if types.TypeType(var) == types.StringType : var = (var,)
1325       return var
1326
1327
1328     epx[MODULE] = ['*--ECRITURES DES RESULTATS']
1329     epx[MODULE] = ['opti K2GP']
1330     # Entete de la commande Europlexus courante
1331     epx[MODULE].append('ECRITURE')
1332
1333
1334     # Traitement du mot-cle facteur OBSERVATION (EPX = LISTING)
1335 # AA    listing_fact = self.ECRITURE['LISTING']
1336     listing_fact = self.OBSERVATION
1337     nom_cham = string2list(listing_fact['NOM_CHAM'])
1338
1339     cle_freq_listing, vale_freq_listing = get_freq(listing_fact)
1340 # AA   cles_entite = ['POINTS','ELEMEMTS']
1341     dcles_entite = {'POINT':'GROUP_NO', 'ELEM':'GROUP_MA'}
1342 # AA    dcles_tout   = {'POINTS':'TOUT_GROUP_NO', 'ELEMEMTS':'GROUP_MA'}
1343     cles_entite = dcles_entite.keys()
1344
1345     # Ecriture format Europlexus
1346
1347     # Ecriture LISTING
1348     st = 2*' '
1349     for cham_aster in nom_cham:
1350       cham_epx = self.dic_champ[cham_aster]
1351       st +=  '%s ' % cham_epx
1352     st += ' %s %s' % (cle_freq_listing,vale_freq_listing)
1353     st += ' NOPO NOEL'
1354     epx[MODULE].append(st)
1355     for cle in cles_entite:
1356 # AA    for cle in cles_entite :
1357 # AA      entite_geo = self.get_motcle(listing_fact ,cle, code_mess=None)
1358 # AA       entite_geo = string2list(entite_geo)
1359
1360        entite_geo = string2list(listing_fact[dcles_entite[cle]])
1361        # if listing_fact['TOUT_%s' % dcles_entite[cle]] == 'OUI': epx[MODULE].append(2*' ' +'%s TOUS ' % cle)
1362        # elif entite_geo is None:                                 epx[MODULE].append(2*' ' +'NO%s' % cle)
1363        # else:
1364           # epx[MODULE].append(2*' ' +'%s LECT' %cle)
1365           # for group in entite_geo :
1366              # epx[MODULE].append(6*' '+group)
1367           # epx[MODULE].append(2*' '+'TERM')
1368
1369 #        if entite_geo is None :
1370 #           epx[MODULE].append(2*' ' +'NO%s' %cle)
1371 #        elif  entite_geo[0] == 'TOUS' :
1372 #          epx[MODULE].append(2*' ' +'%s TOUS ' %cle)
1373 #        else :
1374 #           epx[MODULE].append(2*' ' +'%s LECT' %cle)
1375 #           for group in entite_geo :
1376 #              epx[MODULE].append(6*' '+group)
1377 #           epx[MODULE].append(2*' '+'TERM')
1378 #
1379
1380     # Ecriture FICHIER ALICE UTILISE par le mot-cle facteur COURBE
1381 # AA    courbe_fact = self.ECRITURE['COURBE']
1382     courbe_fact = self.COURBE
1383     if courbe_fact is not None :
1384
1385       # dcourbe=[]
1386       # for j in courbe_fact:
1387          # dcourbe.append(j.cree_dict_valeurs(j.mc_liste))
1388          # for i in dcourbe[-1].keys():
1389             # if dcourbe[-1][i]==None : del dcourbe[-1][i]
1390
1391       # if debug: print 'dcourbe=', dcourbe
1392
1393       cle_freq, vale_freq = get_freq2()
1394       fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT']
1395       epx[MODULE].append(2*' ' + "FICH ALIT 11  %s %s" %(cle_freq,vale_freq))
1396
1397       # Liste les noeuds a postraiter
1398       lnoeuds=sets.Set([])
1399       lmailles=sets.Set([])
1400       for courbe in courbe_fact :
1401         if courbe['GROUP_NO'] != None :
1402             noeuds = courbe['GROUP_NO']
1403             if debug: print type(noeuds)
1404             # liste de noeud ou un seul noeud ?
1405             if type(noeuds) == tuple :
1406                 for el in noeuds :
1407                     lnoeuds.add(el)
1408             else :
1409                 lnoeuds.add(noeuds)
1410         elif courbe['GROUP_MA'] != None :
1411             mailles = courbe['GROUP_MA']
1412             if debug: print type(mailles)
1413             # liste de mailles ou une seule maille ?
1414             if type(mailles ) == tuple :
1415                 for el in mailles :
1416                     lmailles.add(el)
1417             else :
1418                 lmailles.add(mailles)
1419         else :
1420             raise 'Erreur ni noeud ni maille'
1421       # sys.exit()
1422       # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F')
1423       # tables = self.setlist(tables)
1424
1425       # icourbe = 0
1426       # for table in tables:
1427         # icourbe += 1
1428         # noeud = table['NOEUD']
1429         # list_noeuds.append(noeud)
1430       # Ecriture la liste des noeuds sous format epx
1431       if lnoeuds :
1432           epx[MODULE].append(4*' ' +'POINTS')
1433           epx[MODULE].append(6*' ' +'LECT ')
1434           for noeud in lnoeuds :
1435             epx[MODULE].append(8*' '+noeud)
1436           epx[MODULE].append(6*' '+'TERM')
1437       if lmailles :
1438           epx[MODULE].append(4*' ' +'ELEM')
1439           epx[MODULE].append(6*' ' +'LECT ')
1440           for maille in lmailles :
1441             epx[MODULE].append(8*' '+maille)
1442           epx[MODULE].append(6*' '+'TERM')
1443
1444
1445       # Pas besoin d'elements
1446       # epx[MODULE].append(4*' ' + 'NOELEMENTS')
1447
1448     # Ecriture fichier MED representant les champs aux noeuds et aux points de gauss
1449     # Traitement du mot-cle facteur ARCHIVAGE
1450 #    # Traitement du mot-cle facteur CHAMP
1451 #    champ_fact = self.ECRITURE['CHAMP']
1452     champ_fact = self.ARCHIVAGE
1453     if champ_fact is not None :
1454       cle_freq_champ,vale_freq_champ = get_freq(champ_fact)
1455       epx[MODULE].append(2*' ' + 'FICHIER MED')
1456       # chemin complet du fichier med
1457       fichier_med = self.pwd + self.REPE + os.sep + self.nom_fichiers['MED']
1458       epx[MODULE].append(2*' ' + "'%s'" %fichier_med)
1459       cle_freq,vale_freq = get_freq(champ_fact)
1460       epx[MODULE].append(2*' ' + ' %s %s' %(cle_freq_champ,vale_freq_champ))
1461
1462       # groupes de mailles du modele
1463       entite_geo={}
1464       entite_geo['ELEM'] = []
1465       for model in ['DKT3','Q4GS'] :
1466          if model in self.modelisations :
1467              entite_geo['ELEM'].extend(self.dic_gma[model])
1468       entite_geo['POINT'] = []
1469       for model in ['DKT3','Q4GS','POUT'] :
1470          if model in self.modelisations :
1471              entite_geo['POINT'].extend(self.dic_gma[model])
1472       for cle in cles_entite :
1473        epx[MODULE].append(2*' ' +'%s LECT' %cle)
1474        for group in entite_geo[cle] :
1475           epx[MODULE].append(6*' '+group)
1476        epx[MODULE].append(2*' '+'TERM')
1477
1478
1479     # ecriture CAST2000
1480     # __temp
1481     fichier_cast2000 = 'fort.%i' %unite_cast2000
1482     if unite_cast2000 and os.path.isfile(fichier_cast2000) :
1483       # titre
1484       epx[MODULE].append('\n*-- CAST2000')
1485       fd = open(fichier_cast2000,'r')
1486       lst = fd.readlines()
1487       fd.close()
1488       for st in lst :
1489         st = string.replace(st,'\n','')
1490         epx[MODULE].append(st)
1491
1492     # Une ligne de saut
1493     epx[MODULE].append('\n')
1494
1495 #-----------------------------------------------------------------------
1496
1497   def export_POST_COURBE(self):
1498
1499     # Suite de postraitement permettant d'ecrire des fichiers ASCII
1500     # des grandeurs demandees
1501
1502     # Tester si le mot_cle facteur COURBE a ete renseigne
1503 # AA   courbe_fact = self.ECRITURE['COURBE']
1504     courbe_fact = self.COURBE
1505     if courbe_fact is None : return
1506
1507     epx = self.epx
1508
1509     # Cle identifiant
1510     MODULE = 'POST_COURBE'
1511
1512     # Ecriture fort Europlexus
1513     # Entete de la commande courante
1514     epx[MODULE] = ['SUITE\n']
1515     # epx[MODULE].append("'TITRE'")
1516 #    unite_alit = self.get_motcle(courbe_fact,'UNITE_ALIT',code_mess=None)
1517 #    if debug: print 'unite_alit=', unite_alit
1518     if self.UNITE_COURBE: fichier_courbes = os.path.join(self.pwd, 'fort.%s' % str(self.UNITE_COURBE))
1519     else:                 fichier_courbes = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN']
1520     fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT']
1521     epx[MODULE].append("RESULTAT ALICE TEMPS 11")
1522     epx[MODULE].append("OPNF FORMAT 17 '%s'" %fichier_courbes)
1523     epx[MODULE].append("SORTIES GRAPHIQUES")
1524     # epx[MODULE].append("PERFO '%s'"%fichier_courbes)
1525     epx[MODULE].append("AXTEMPS 1. 'TEMPS(s)'")
1526
1527     # recuperer le mot-cle facteur COURBE
1528 # AA    courbe_fact = self.ECRITURE['COURBE']
1529     courbe_fact = self.COURBE
1530     # recuperer les mot_cle TABLE
1531     # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F')
1532     #tables = self.setlist(tables)
1533
1534     # Dictionnaire decrivant les legendes des abscisses et ordodonnees des courbes imprimees
1535     # etl utilisee dans get_tables
1536     self.legend_courbes = {}
1537     entites_courbe = ['GROUP_NO','GROUP_MA']
1538     entite_EPX={'GROUP_NO' : 'NOEUD', 'GROUP_MA' : 'ELEM'}
1539     icourbe = 0
1540     # for table in tables:
1541     lnoeuds = []
1542     for table in courbe_fact :
1543       for entite_type in entites_courbe :
1544         try : entite = table[entite_type]
1545         except : entite = None
1546         if entite is not None :
1547             cham_aster = table['NOM_CHAM']
1548             cmp_aster = table['NOM_CMP']
1549             cham_epx = self.dic_champ[cham_aster]
1550             cmp_epx  = self.dic_cmp[cham_aster][cmp_aster]
1551             ylabel   = cham_aster + '_' + cmp_aster
1552             #ylabel   = cmp_aster
1553             if type(entite) is not tuple : entite = [entite,]
1554             for el in entite :
1555                 icourbe+=1
1556                 label = ylabel + '_%s'%el
1557                 if entite_type == 'GROUP_MA' :
1558                     label = label+'_%s'%table['NUM_GAUSS']
1559                 st = "COURBE %i '%s' %s COMP %i "% (icourbe,label,cham_epx,cmp_epx)
1560                 if entite_type == 'GROUP_MA' :
1561                     st=st+"GAUSS %i "%table['NUM_GAUSS']
1562                 st=st+"%s LECT %s TERM"%(entite_EPX[entite_type],el)
1563                 if debug: print 'st = %s'%st
1564                 epx[MODULE].append(st)
1565                 # epx[MODULE].append("LIST %i AXES 1. '%s'" % (icourbe,ylabel))
1566                 st = "LIST %s AXES 1. '%s'" % (icourbe,label)
1567                 if debug: print 'st = %s'%st
1568                 epx[MODULE].append(st)
1569                 self.legend_courbes[icourbe] = ['TEMPS',label]
1570
1571
1572
1573     # Une ligne de saut
1574     epx[MODULE].append('\n')
1575
1576 #-----------------------------------------------------------------------
1577   def export_CALCUL(self):
1578
1579     epx = self.epx
1580
1581     # CLe identifiant
1582     MODULE = 'CALCUL'
1583
1584     # Entete de la commande Europlexus courante
1585     epx[MODULE] = ['*--OPTION DE CALCUL']
1586     epx[MODULE].append('')
1587     type_discr = self.CALCUL['TYPE_DISCRETISATION']
1588
1589     epx[MODULE].append('OPTION PAS %s' %type_discr)
1590
1591     if  type_discr == 'AUTO':
1592       cstab = self.CALCUL['CSTAB']
1593       epx[MODULE].append(7*' ' + 'CSTAB %s' %cstab)
1594
1595     listInterfaces = self.INTERFACES
1596     listDomaines = self.DOMAINES
1597     domaineInterfaces = {}
1598     if listDomaines :
1599         epx[MODULE].append('\n')
1600         epx[MODULE].append('*--DEFINITION DES SOUS DOMAINES')
1601         epx[MODULE].append('')
1602         epx[MODULE].append('STRUCTURE %s'%len(listDomaines))
1603         for interface in listInterfaces :
1604             Lgma1 = self.setlist(interface['GROUP_MA_1'])
1605             Lgma2 = self.setlist(interface['GROUP_MA_2'])
1606             idS1 = interface['IDENT_DOMAINE_1']
1607             idS2 = interface['IDENT_DOMAINE_2']
1608             if not domaineInterfaces.has_key(idS1) :
1609                 domaineInterfaces[idS1]= []
1610             if not domaineInterfaces.has_key(idS2) :
1611                 domaineInterfaces[idS2]= []
1612             domaineInterfaces[idS1].extend(Lgma1)
1613             domaineInterfaces[idS2].extend(Lgma2)
1614     else :
1615         listDomaines = []
1616     for domaine in listDomaines :
1617         Lgma = self.setlist(domaine['GROUP_MA'])
1618         id  = domaine['IDENTIFIANT']
1619         epx[MODULE].append(3*' '+'DOMA LECT')
1620         for gma in Lgma :
1621             epx[MODULE].append(12*' '+gma)
1622         for gma in domaineInterfaces[id] :
1623             epx[MODULE].append(12*' '+gma)
1624         epx[MODULE].append(8*' '+'TERM')
1625         epx[MODULE].append(8*' '+'IDENTIFIANT %s\n'%id)
1626
1627
1628     if listInterfaces :
1629         epx[MODULE].append('')
1630         epx[MODULE].append('INTERFACE %s'%len(listInterfaces))
1631     else :
1632         listInterfaces = []
1633     for interface in listInterfaces :
1634         Lgma1 = self.setlist(interface['GROUP_MA_1'])
1635         Lgma2 = self.setlist(interface['GROUP_MA_2'])
1636         idS1 = interface['IDENT_DOMAINE_1']
1637         idS2 = interface['IDENT_DOMAINE_2']
1638         tole = interface['TOLE']
1639         epx[MODULE].append(3*' '+'MORTAR TOLE %s'%tole)
1640         epx[MODULE].append(7*' '+'DOMA %s LECT'%idS1)
1641         for gma in Lgma1 :
1642             epx[MODULE].append(13*' '+gma)
1643         epx[MODULE].append(10*' '+'TERM')
1644         epx[MODULE].append(7*' '+'DOMA %s LECT'%idS2)
1645         for gma in Lgma2 :
1646             epx[MODULE].append(13*' '+gma)
1647         epx[MODULE].append(10*' '+'TERM')
1648
1649     epx[MODULE].append('\n')
1650     epx[MODULE].append('*--LANCEMENT DE CALCUL')
1651     epx[MODULE].append('')
1652     calcul = 'CALCUL'
1653 # AAA    cles = ['INST_INIT','PASFIX','INST_FIN','DTMAX']
1654     cles = ['INST_INIT','PASFIX','INST_FIN']
1655     dcles = {'INST_INIT':'TINI', 'PASFIX':'PASFIX', 'INST_FIN':'TFIN'}
1656     for cle in dcles.keys():
1657       try : calcul += ' %s %s' %(dcles[cle], self.CALCUL[cle])
1658       except : pass
1659     # Doit etre mis en entier
1660     try : calcul += ' %s %d' %('NMAX',self.CALCUL['NMAX'])
1661     except : pass
1662     epx[MODULE].append(calcul)
1663     epx[MODULE].append('\n')
1664     #epx[MODULE].append('FIN')
1665
1666
1667 #-----------------------------------------------------------------------
1668   def ecrire_fichier(self,):
1669
1670     fichier = self.REPE + os.sep + self.nom_fichiers['COMMANDE']
1671
1672     # ordre des modules de definition du modele EPX
1673     modules = ['DEBUT','MAILLAGE','DIME','MODELE','CARA_ELEM','FONC_PARASOL','CHAM_MATER','RIGI_PARASOL','EXCIT','ECRITURE','CALCUL','POST_COURBE']
1674
1675     #les modules MODELE et RIGI_PARASOL doivent etre executes avant MAILLAGE
1676     # car le maillage peut etre modifie dans ces modules
1677     modules_exe = []
1678     modules_exe.extend(modules)
1679     modules_exe.remove('MAILLAGE')
1680     modules_exe.append('MAILLAGE')
1681
1682     # Excecution des differentes modules
1683     for module in modules_exe:
1684       fct = 'export_%s' %module
1685       if hasattr(self,fct) :
1686         eval('self.'+fct+'()')
1687       else :
1688         print 'module %s pas encore developpe' %fct
1689
1690     # Ecriture du fichier texte contenant toutes les commandes Europlexus
1691     fd = open(fichier,'w')
1692     for module in modules :
1693       if self.epx.has_key(module) :
1694         for ll in self.epx[module]:
1695           if debug: print 'EPX : %s'%ll
1696           fd.write('%s\n'%ll)
1697     # Fin du fichier de commandes epx
1698     fd.write('FIN')
1699     fd.close()
1700
1701 #-----------------------------------------------------------------------
1702   def get_table(self,icourbe=1,fichier='auto') :
1703
1704     global table
1705
1706     if not hasattr(self,'courbes'):
1707       if fichier == 'auto' : fichier = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN']
1708       if not os.path.isfile(fichier) : return
1709       self.courbes = self.lire_pun(fichier=fichier)
1710
1711     if not os.path.isfile(fichier) : return
1712     if debug: print self.courbes,type(self.courbes)
1713     nc = 0
1714     para_ordonnee = []
1715     dico = []
1716     for icourbe in self.courbes :
1717         valeurs = self.courbes[icourbe]
1718         if debug: print 'icourbe = %s ; valeurs = %s'%(icourbe, valeurs)
1719         if nc == 0 :
1720             para_abscisse = self.legend_courbes[icourbe][0]
1721             vale_abscisse = valeurs[0,:].tolist()
1722             assert (len(para_abscisse)<17)
1723             dico.append({'TYPE_K':'K16','LISTE_R' : vale_abscisse , 'PARA' : para_abscisse})
1724             para_ordonnee = self.legend_courbes[icourbe][1]
1725             vale_ordonnee = valeurs[1,:].tolist()
1726             assert (len(para_ordonnee)<17)
1727             dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee})
1728             nc=1
1729         else :
1730             if ((self.legend_courbes[icourbe][0] == para_abscisse) and (vale_abscisse == valeurs[0,:].tolist())) :
1731                 para_ordonnee = self.legend_courbes[icourbe][1]
1732                 vale_ordonnee = valeurs[1,:].tolist()
1733                 assert (len(para_ordonnee)<17)
1734                 dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee})
1735             else :
1736                 raise 'Table non compatible'
1737
1738     table = CREA_TABLE( LISTE =dico
1739                       );
1740
1741     if 0 :
1742       unite = self.get_unite_libre()
1743       unite = 90
1744       DEFI_FICHIER(UNITE=unite,ACTION='ASSOCIER');
1745
1746       IMPR_TABLE(UNITE = unite,
1747                FORMAT = 'XMGRACE',
1748                TABLE = table,
1749                LEGENDE_X = para_abscisse,
1750                LEGENDE_Y = para_ordonnee,
1751                LEGENDE   = 'test'
1752            );
1753
1754       os.system('xmgrace fort.%i' %unite)
1755
1756       DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');
1757
1758
1759 #-----------------------------------------------------------------------
1760   def get_resu(self,fichier_med='auto'):
1761
1762     # Rendre global le resu pour qu'il soit accepte dans self.DeclareOut
1763     global resu
1764
1765     if fichier_med == 'auto' : fichier_med = self.REPE + os.sep + self.nom_fichiers['MED']
1766
1767     if debug: print fichier_med
1768     if not os.path.isfile(fichier_med) :
1769        print "Pas de fichier MED !"
1770        return
1771
1772     # Format med des champs depl, vite et acce
1773     format_med =[_F(NOM_CHAM_MED='CHAMP___DEPLACEMENT___001',
1774                     NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
1775                     NOM_CMP_MED=('UX','UY','UZ','RX','RY','RZ'),
1776                     NOM_CHAM    ='DEPL' ),
1777                  _F(NOM_CHAM_MED='CHAMP___VITESSE___001',
1778                     NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
1779                     NOM_CMP_MED=('VX','VY','VZ','RX','RY','RZ'),
1780                     NOM_CHAM    ='VITE' ),
1781                  _F(NOM_CHAM_MED='CHAMP___ACCELERATION___001',
1782                     NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
1783                     NOM_CMP_MED=('GX','GY','GZ','RX','RY','RZ'),
1784                     NOM_CHAM    ='ACCE' ),
1785                 ]
1786
1787     # Dicionnaire permettant de faire la correspondance des champs aux pts de gauss entre le med de europlexus et aster
1788     dic_cmp_gauss = {}
1789
1790     dic_cmp_gauss['CONTRAINTE'] = {'DKT3': {'NOM_CMP'     : ('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),
1791                                             'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6',),},
1792                                    'Q4GS': {'NOM_CMP'     : ('NXX','NYY','NXY','MXX','MYY','MXY','QX','QY'),
1793                                             'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6','SIG7','SIG8'),},
1794                                    'POUT' : {}
1795
1796                                    }
1797
1798     dic_cmp_gauss['DEFORMATION'] = {'DKT3': {'NOM_CMP'     : ('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),
1799                                             'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6',),},
1800                                    'Q4GS': {'NOM_CMP'     : ('EXX','EYY','EXY','KXX','KYY','KXY','GAX','GAY'),
1801                                             'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6','EPS7','EPS8'),},
1802                                    'POUT' : {}
1803
1804                                    }
1805
1806     dic_cmp_gauss['ECROUISSAGE'] = {'DKT3': {'NOM_CMP'     : ('V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19'),
1807                                             'NOM_CMP_MED'  : ('VAR1','VAR2','VAR3','VAR4','VAR5','VAR6','VAR7','VAR8','VAR9','VAR10','VAR11','VAR12','VAR13','VAR14','VAR15','VAR16','VAR17','VAR18','VAR19'),},
1808                                    'Q4GS' : {'NOM_CMP'     : ('V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19'),
1809                                             'NOM_CMP_MED'  : ('VAR1','VAR2','VAR3','VAR4','VAR5','VAR6','VAR7','VAR8','VAR9','VAR10','VAR11','VAR12','VAR13','VAR14','VAR15','VAR16','VAR17','VAR18','VAR19'),},
1810                                    'POUT' : {}
1811
1812                                     }
1813     tupVar = ('X1','X2','X3','X4','X5','X6','X7','X8','X9','X10','X11','X12','X13','X14','X15','X16','X17','X18','X19')
1814
1815     # Dictionnaire permettant de traduire le champ epx en med au nom asscie dans aster
1816 # AA    epx2aster = {'CONTRAINTE':'SIEF_ELGA','ECROUISSAGE':'VARI_ELGA'}
1817     epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA_DEPL','ECROUISSAGE':'VARI_ELGA'}
1818
1819 # AA : desactive pour le moment
1820 #     # Enrichir la liste format_med par les champs aux pts de gauss
1821 #     imode = 0
1822 #     if debug: print 'self.modelisations',self.modelisations
1823 #     for modelisation in self.modelisations :
1824 #       #if modelisation in ['Q4GS','DKT3'] :
1825 #         imode += 1
1826 #         numero =  string.replace('%3.i' %imode,' ','0')
1827 #         for champ in dic_cmp_gauss.keys():
1828 #           if len(dic_cmp_gauss[champ][modelisation]) > 0 :
1829 #             nom_cham_med = 'CHAMP___'+ champ + (13-len(champ))*'_' + numero
1830 #             nom_cham = epx2aster[champ]
1831 #             nom_cmp = dic_cmp_gauss[champ][modelisation]['NOM_CMP']
1832 #             nom_cmp_med = dic_cmp_gauss[champ][modelisation]['NOM_CMP_MED']
1833 #             # ajouer a la list format_med
1834 #             format_med.append(_F(NOM_CHAM_MED=nom_cham_med,NOM_CMP=nom_cmp,
1835 #                                NOM_CMP_MED=nom_cmp_med,NOM_CHAM=nom_cham)
1836 #                            )
1837
1838     # Lire le fichier med avec les options choisies dans la liste format_med
1839     unite = self.get_unite_libre()
1840     DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');
1841     fort = 'fort.%i' %unite
1842     if os.path.isfile(fort) : os.remove(fort)
1843
1844     os.symlink(fichier_med,fort)
1845
1846     # Regeneration des mots-cles EXCIT passés en argument de la macro
1847     dExcit=[]
1848     for j in self.EXCIT :
1849        dExcit.append(j.cree_dict_valeurs(j.mc_liste))
1850        for i in dExcit[-1].keys():
1851           if dExcit[-1][i]==None : del dExcit[-1][i]
1852     resu = LIRE_RESU(TYPE_RESU='EVOL_NOLI',
1853 #                  VERI_ELGA='NON',
1854                   FORMAT='MED',
1855                   MODELE=self.NEW_MODELE,
1856                   FORMAT_MED=format_med,
1857                   UNITE=unite,
1858                   CHAM_MATER=self.CHAM_MATER,
1859                   CARA_ELEM=self.CARA_ELEM,
1860                   TOUT_ORDRE='OUI',
1861                   EXCIT=dExcit,
1862                   INFO=self.INFO,
1863                   );
1864
1865     __EPN = CREA_CHAMP(
1866             INFO      = self.INFO,
1867             TYPE_CHAM = 'ELGA_NEUT_R',
1868             OPERATION = 'AFFE',
1869             MODELE    = self.NEW_MODELE,
1870             PROL_ZERO = 'OUI',
1871             AFFE      = self.listEpais,
1872             )
1873     __EPN2 = CREA_CHAMP(
1874             INFO      = self.INFO,
1875             TYPE_CHAM = 'ELGA_NEUT_R',
1876             OPERATION = 'AFFE',
1877             MODELE    = self.NEW_MODELE,
1878             PROL_ZERO = 'OUI',
1879             AFFE      = self.listEpais2,
1880             )
1881     __UNN = CREA_CHAMP(
1882             INFO      = self.INFO,
1883             TYPE_CHAM = 'ELGA_NEUT_R',
1884             OPERATION = 'AFFE',
1885             MODELE    = self.NEW_MODELE,
1886             PROL_ZERO = 'OUI',
1887             AFFE = _F(VALE=(1.,1.), TOUT='OUI', NOM_CMP=('X21','X22')),
1888             )
1889     __UNDEU = CREA_CHAMP(
1890             INFO      = self.INFO,
1891             TYPE_CHAM = 'ELGA_NEUT_R',
1892             OPERATION = 'AFFE',
1893             MODELE    = self.NEW_MODELE,
1894             PROL_ZERO = 'OUI',
1895             AFFE = _F(VALE=(1.,1./2.), TOUT='OUI', NOM_CMP=('X21','X22')),
1896             )
1897     __FONC1 = FORMULE(VALE='X1*X21',NOM_PARA=('X1','X21'))
1898     __FONC2 = FORMULE(VALE='X2*X21',NOM_PARA=('X2','X21'))
1899     __FONC3 = FORMULE(VALE='X3*X21',NOM_PARA=('X3','X21'))
1900     __FONC4 = FORMULE(VALE='X4*X22',NOM_PARA=('X4','X22'))
1901     __FONC5 = FORMULE(VALE='X5*X22',NOM_PARA=('X5','X22'))
1902     __FONC6 = FORMULE(VALE='X6*X22',NOM_PARA=('X6','X22'))
1903     __FONC7 = FORMULE(VALE='X7*X21',NOM_PARA=('X7','X21'))
1904     __FONC8 = FORMULE(VALE='X8*X21',NOM_PARA=('X8','X21'))
1905     __FONC11 = FORMULE(VALE='X11*X21',NOM_PARA=('X11','X21'))
1906     __FONC12 = FORMULE(VALE='X12*X21',NOM_PARA=('X12','X21'))
1907     __FONC13 = FORMULE(VALE='X13*X21',NOM_PARA=('X13','X21'))
1908     __FONC14 = FORMULE(VALE='X14*X22',NOM_PARA=('X14','X22'))
1909     __FONC15 = FORMULE(VALE='X15*X22',NOM_PARA=('X15','X22'))
1910     __FONC16 = FORMULE(VALE='X16*X22',NOM_PARA=('X16','X22'))
1911     __FONC17 = FORMULE(VALE='X17*X21',NOM_PARA=('X17','X21'))
1912     __FONC18 = FORMULE(VALE='X18*X21',NOM_PARA=('X18','X21'))
1913
1914     __FONE1 = FORMULE(VALE='X1*X21',NOM_PARA=('X1','X21'))
1915     __FONE2 = FORMULE(VALE='X2*X21',NOM_PARA=('X2','X21'))
1916     __FONE3 = FORMULE(VALE='X3*X22',NOM_PARA=('X3','X22'))
1917     __FONE4 = FORMULE(VALE='X4*X21',NOM_PARA=('X4','X21'))
1918     __FONE5 = FORMULE(VALE='X5*X21',NOM_PARA=('X5','X21'))
1919     __FONE6 = FORMULE(VALE='X6*X22',NOM_PARA=('X6','X22'))
1920     __FONE7 = FORMULE(VALE='X7*X21',NOM_PARA=('X7','X21'))
1921     __FONE8 = FORMULE(VALE='X8*X21',NOM_PARA=('X8','X21'))
1922     __FONE9 = FORMULE(VALE='X9*X21',NOM_PARA=('X9','X21'))
1923     __FONE10 = FORMULE(VALE='X10*X21',NOM_PARA=('X10','X21'))
1924     __FONE11 = FORMULE(VALE='X11*X21',NOM_PARA=('X11','X21'))
1925     __FONE12 = FORMULE(VALE='X12*X21',NOM_PARA=('X12','X21'))
1926     __FONE13 = FORMULE(VALE='X13*X21',NOM_PARA=('X13','X21'))
1927     __FONE14 = FORMULE(VALE='X14*X21',NOM_PARA=('X14','X21'))
1928     __FONE15 = FORMULE(VALE='X15*X21',NOM_PARA=('X15','X21'))
1929     __FONE16 = FORMULE(VALE='X16*X21',NOM_PARA=('X16','X21'))
1930     __FONE17 = FORMULE(VALE='X17*X21',NOM_PARA=('X17','X21'))
1931     __FONE18 = FORMULE(VALE='X18*X21',NOM_PARA=('X18','X21'))
1932     __FONE19 = FORMULE(VALE='X19*X21',NOM_PARA=('X19','X21'))
1933
1934     __FONCC = CREA_CHAMP(
1935         INFO      = self.INFO,
1936         TYPE_CHAM = 'ELGA_NEUT_F',
1937         OPERATION = 'AFFE',
1938         MODELE    = self.NEW_MODELE,
1939         PROL_ZERO = 'OUI',
1940         AFFE      = _F(
1941                TOUT    = 'OUI',
1942                NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8','X11','X12','X13','X14','X15','X16','X17','X18'),
1943                VALE_F  = (__FONC1,__FONC2,__FONC3,__FONC4,__FONC5,__FONC6,__FONC7,__FONC8,__FONC11,__FONC12,__FONC13,
1944                           __FONC14,__FONC15,__FONC16,__FONC17,__FONC18)),
1945                           )
1946     __FONCC2 = CREA_CHAMP(
1947         INFO      = self.INFO,
1948         TYPE_CHAM = 'ELGA_NEUT_F',
1949         OPERATION = 'AFFE',
1950         MODELE    = self.NEW_MODELE,
1951         PROL_ZERO = 'OUI',
1952         AFFE      = _F(
1953                TOUT    = 'OUI',
1954                NOM_CMP = tupVar,
1955      #          VALE_F  = (__FONE1,__FONE2)
1956                VALE_F  = (__FONE1,__FONE2,__FONE3,__FONE4,__FONE5,__FONE6,__FONE7,__FONE8,__FONE9,__FONE10,__FONE11,__FONE12,__FONE13,__FONE14,__FONE15,__FONE16,__FONE17,__FONE18,__FONE19)
1957                ),
1958                )
1959     listEffg = []
1960     i=0
1961     listType=[]
1962     __SIG11 = [None]*10
1963     __SIG21 = [None]*10
1964     __ECR11 = [None]*10
1965
1966     # Pour masquer certaines alarmes
1967     from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
1968     MasquerAlarme('MED_83')
1969     MasquerAlarme('MED_98')
1970
1971     while 1:
1972         # index=1
1973         # pas = self.ARCHIVAGE['PAS_NBRE']
1974         # dicDetr=[]
1975         # if 'Q4GS' in self.modelisations :
1976             err = 0
1977             try :
1978                 __SIG11[i] = LIRE_CHAMP(
1979                     INFO        = self.INFO,
1980                     TYPE_CHAM   = 'ELGA_SIEF_R',
1981                     UNITE       = 99,
1982                     NUME_PT     = 0,
1983                     MODELE      = self.NEW_MODELE,
1984                     MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
1985                     PROL_ZERO   = 'OUI',
1986                     NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(i+1),
1987                     NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'],
1988                     NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED'])
1989                 # dicDetr.append({'NOM' : __SIG11})
1990                 DETRUIRE(CONCEPT=_F(NOM = __SIG11[i]), INFO=1)
1991                 listType.append('Q4GS')
1992                 # index=2
1993             except :
1994                 err+=1
1995             try :
1996                 __SIG21[i] = LIRE_CHAMP(
1997                     INFO        = self.INFO,
1998                     TYPE_CHAM   = 'ELGA_SIEF_R',
1999                     UNITE       = 99,
2000                     NUME_PT     = 0,
2001                     MODELE      = self.NEW_MODELE,
2002                     MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2003                     PROL_ZERO   = 'OUI',
2004                     NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(i+1),
2005                     NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
2006                     NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']),
2007                 DETRUIRE(CONCEPT=_F(NOM = __SIG21[i]), INFO=1)
2008                 if len(listType)<i+1 :
2009                     listType.append('DKT3')
2010             except :
2011                 err+=1
2012             if err<2 :
2013                 i+=1
2014             else :
2015                 break
2016         # if 'DKT3' in self.modelisations :
2017             # try :
2018                 # __SIG21 = LIRE_CHAMP(
2019                     # INFO        = self.INFO,
2020                     # TYPE_CHAM   = 'ELGA_SIEF_R',
2021                     # UNITE       = 99,
2022                     # NUME_PT     = i*pas,
2023                     # MODELE      = self.NEW_MODELE,
2024                     # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2025                     # PROL_ZERO   = 'OUI',
2026                     # NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%index,
2027                     # NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
2028                     # NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']),
2029                 # dicDetr.append({'NOM' : __SIG21})
2030
2031             # except :
2032                 # err +=1
2033         # if err > 1 :
2034             # break
2035         # DETRUIRE(CONCEPT=dicDetr)
2036         # i+=1
2037
2038     # Pour la gestion des alarmes
2039     RetablirAlarme('MED_83')
2040     RetablirAlarme('MED_98')
2041
2042
2043     nbChamp = i
2044
2045     listVari = [0]*nbChamp
2046
2047     for i in xrange(nbChamp) :
2048             if listType[i] == 'Q4GS' :
2049                try :
2050                    __ECR11[i] = LIRE_CHAMP(
2051                        INFO        = self.INFO,
2052                        TYPE_CHAM   = 'ELGA_VARI_R',
2053                        UNITE       = 99,
2054                        NUME_PT     = 0,
2055                        MODELE      = self.NEW_MODELE,
2056                        MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2057                        PROL_ZERO   = 'OUI',
2058                        NOM_MED     = 'CHAMP___ECROUISSAGE__00%d'%(i+1),
2059                        NOM_CMP     = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'],
2060                        NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED'])
2061                    # dicDetr.append({'NOM' : __SIG11})
2062                    DETRUIRE(CONCEPT=_F(NOM = __ECR11[i]), INFO=1)
2063                    listVari[i]=1
2064                except :
2065                    err+=1
2066             elif listType[i] == 'DKT3' :
2067                try :
2068                    __ECR11[i] = LIRE_CHAMP(
2069                        INFO        = self.INFO,
2070                        TYPE_CHAM   = 'ELGA_VARI_R',
2071                        UNITE       = 99,
2072                        NUME_PT     = 0,
2073                        MODELE      = self.NEW_MODELE,
2074                        MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2075                        PROL_ZERO   = 'OUI',
2076                        NOM_MED     = 'CHAMP___ECROUISSAGE__00%d'%(i+1),
2077                        NOM_CMP     = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP'],
2078                        NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP_MED'])
2079                    # dicDetr.append({'NOM' : __SIG11})
2080                    DETRUIRE(CONCEPT=_F(NOM = __ECR11[i]), INFO=1)
2081                    listVari[i]=1
2082                except :
2083                   err+=1
2084
2085
2086
2087     itot=len(resu.LIST_PARA()['INST'])
2088     __EFFG=[None]*itot
2089     # __EPSG=[None]*itot
2090     __ECRG=[None]*itot
2091     __SIG1 = [None]*nbChamp
2092     __SIG2 = [None]*nbChamp
2093     __ECR1 = [None]*nbChamp
2094     __ECR2 = [None]*nbChamp
2095     for i in xrange(itot) :
2096         dicAffe=[]
2097         dicAffe2=[]
2098         dicAffe3=[]
2099         index=1
2100         pas = self.ARCHIVAGE['PAS_NBRE']
2101         dicAsse = [{'TOUT' : 'OUI', 'CHAM_GD' : __EPN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
2102         dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPN2, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
2103         dicAsse2 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
2104         dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
2105         dicAsse3 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNDEU, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
2106         dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNDEU, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
2107         dicDetr=[]
2108         # if 'Q4GS' in self.modelisations :
2109         for j in xrange(nbChamp) :
2110             if listType[j] == 'Q4GS' :
2111                 __SIG1[j] = LIRE_CHAMP(
2112                     INFO        = self.INFO,
2113                     TYPE_CHAM   = 'ELGA_SIEF_R',
2114                     UNITE       = 99,
2115                     NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
2116                     MODELE      = self.NEW_MODELE,
2117                     MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2118                     PROL_ZERO   = 'OUI',
2119                     NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(j+1),
2120                     NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'],
2121                     NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED'],
2122                         )
2123                 dicDetr.append({'NOM' : __SIG1[j]})
2124                 dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG1[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']),
2125                             'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.})
2126                 # __EPS1 = LIRE_CHAMP(
2127                     # INFO        = self.INFO,
2128                     # TYPE_CHAM   = 'ELGA_EPSI_R',
2129                     # UNITE       = 99,
2130                     # NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
2131                     # MODELE      = self.NEW_MODELE,
2132                     # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2133                     # PROL_ZERO   = 'OUI',
2134                     # NOM_MED     = 'CHAMP___DEFORM_TOT___001',
2135                     # NOM_CMP     = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP'],
2136                     # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP_MED'])
2137                 if listVari[j] :
2138                     __ECR1[j] = LIRE_CHAMP(
2139                         INFO     = self.INFO,
2140                         TYPE_CHAM   = 'ELGA_VARI_R',
2141                         UNITE    = 99,
2142                         NUME_PT  = resu.LIST_PARA()['NUME_ORDRE'][i],
2143                         MODELE   = self.NEW_MODELE,
2144                         MAILLAGE         = self.reupere_structure(self.MODELE,'MAILLAGE'),
2145                         PROL_ZERO   = 'OUI',
2146                         NOM_MED  = 'CHAMP___ECROUISSAGE__00%d'%(j+1),
2147                         NOM_CMP  = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'],
2148                         NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED'])
2149                     dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR1[j], 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP']),
2150                              'NOM_CMP_RESU' : tupVar, 'CUMUL' : 'OUI','COEF_R':1.})
2151                     dicDetr.append({'NOM' : __ECR1[j]})
2152                 # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS1, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']),
2153                             # 'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.})
2154             else :
2155                 __SIG2[j] = LIRE_CHAMP(
2156                     INFO        = self.INFO,
2157                     TYPE_CHAM   = 'ELGA_SIEF_R',
2158                     UNITE       = 99,
2159                     NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
2160                     MODELE      = self.NEW_MODELE,
2161                     MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2162                     PROL_ZERO   = 'OUI',
2163                     NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(j+1),
2164                     NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
2165                     NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED'],
2166                     )
2167                 dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG2[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP']),
2168                                 'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.})
2169                 dicDetr.append({'NOM' : __SIG2[j]})
2170                 # __EPS2 = LIRE_CHAMP(
2171                     # INFO        = self.INFO,
2172                     # TYPE_CHAM   = 'ELGA_EPSI_R',
2173                     # UNITE       = 99,
2174                     # NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
2175                     # MODELE      = self.NEW_MODELE,
2176                     # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
2177                     # PROL_ZERO   = 'OUI',
2178                     # NOM_MED     = 'CHAMP___DEFORM_TOT___00%d'%index,
2179                     # NOM_CMP     = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP'],
2180                     # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP_MED']),
2181                 if listVari[j] :
2182
2183                    __ECR2[j] = LIRE_CHAMP(
2184                        INFO      = self.INFO,
2185                        TYPE_CHAM   = 'ELGA_VARI_R',
2186                        UNITE     = 99,
2187                        NUME_PT   = resu.LIST_PARA()['NUME_ORDRE'][i],
2188                        MODELE    = self.NEW_MODELE,
2189                        MAILLAGE  = self.reupere_structure(self.MODELE,'MAILLAGE'),
2190                        PROL_ZERO   = 'OUI',
2191                        NOM_MED   = 'CHAMP___ECROUISSAGE__00%d'%(j+1),
2192                        NOM_CMP   = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP'],
2193                        NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP_MED'])
2194                    dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR2[j], 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP']),
2195                                    'NOM_CMP_RESU' : tupVar, 'CUMUL' : 'OUI','COEF_R':1.})
2196                    dicDetr.append({'NOM' : __ECR2[j]})
2197                 # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS2, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP']),
2198                                 # 'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.})
2199                 # dicDetr.append({'NOM' : __EPS2})
2200 #                dicDetr.append({'NOM' : __ECR2})
2201                 # dicDetr.append({'NOM' : __EPS1})
2202 #                dicDetr.append({'NOM' : __ECR1})
2203         # if 'DKT3' in self.modelisations:
2204
2205         __SIGN = CREA_CHAMP(
2206             INFO      = self.INFO,
2207             TYPE_CHAM = 'ELGA_NEUT_R',
2208             OPERATION = 'ASSE',
2209             PROL_ZERO = 'OUI',
2210             MODELE    = self.NEW_MODELE,
2211             ASSE      = dicAsse,
2212             )
2213         # __EPSN = CREA_CHAMP(
2214             # INFO      = self.INFO,
2215             # TYPE_CHAM = 'ELGA_NEUT_R',
2216             # OPERATION = 'ASSE',
2217             # PROL_ZERO = 'OUI',
2218             # MODELE    = self.NEW_MODELE,
2219             # ASSE      = dicAsse2)
2220         __ECRN = CREA_CHAMP(
2221              INFO      = self.INFO,
2222              TYPE_CHAM = 'ELGA_NEUT_R',
2223              OPERATION = 'ASSE',
2224              PROL_ZERO = 'OUI',
2225              MODELE    = self.NEW_MODELE,
2226              ASSE      = dicAsse3)
2227         dicDetr.append({'NOM' : __SIGN})
2228         # dicDetr.append({'NOM' : __EPSN})
2229         dicDetr.append({'NOM' : __ECRN})
2230         __EFFGN = CREA_CHAMP(
2231             INFO      = self.INFO,
2232             TYPE_CHAM = 'ELGA_NEUT_R',
2233             OPERATION = 'EVAL',
2234             CHAM_F    = __FONCC,
2235             CHAM_PARA = (__SIGN),
2236           )
2237         # __EPSGN = CREA_CHAMP(
2238             # INFO      = self.INFO,
2239             # TYPE_CHAM = 'ELGA_NEUT_R',
2240             # OPERATION = 'EVAL',
2241             # CHAM_F    = __FONCC,
2242             # CHAM_PARA   = (__EPSN))
2243         __ECRGN = CREA_CHAMP(
2244             INFO      = self.INFO,
2245             TYPE_CHAM = 'ELGA_NEUT_R',
2246             OPERATION = 'EVAL',
2247             CHAM_F    = __FONCC2,
2248             CHAM_PARA   = (__ECRN))
2249         dicDetr.append({'NOM' : __EFFGN})
2250         # dicDetr.append({'NOM' : __EPSGN})
2251         dicDetr.append({'NOM' : __ECRGN})
2252         __EFFG[i] = CREA_CHAMP(
2253             INFO      = self.INFO,
2254             TYPE_CHAM  = 'ELGA_SIEF_R',
2255             OPERATION = 'ASSE',
2256             PROL_ZERO = 'OUI',
2257             MODELE    = self.NEW_MODELE,
2258             ASSE      = _F(
2259                 TOUT = 'OUI',
2260                 CHAM_GD = __EFFGN,
2261                 NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'),
2262                 NOM_CMP_RESU = tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']+dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'])),
2263                 )
2264         # __EPSG[i] = CREA_CHAMP(
2265             # INFO      = self.INFO,
2266             # TYPE_CHAM  = 'ELGA_EPSI_R',
2267             # OPERATION = 'ASSE',
2268             # PROL_ZERO = 'OUI',
2269             # MODELE    = self.NEW_MODELE,
2270             # ASSE      = _F(
2271                 # TOUT = 'OUI',
2272                 # CHAM_GD = __EPSGN,
2273                 # NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'),
2274                 # NOM_CMP_RESU = tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']+dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP'])))
2275         __ECRG[i] = CREA_CHAMP(
2276             INFO      = self.INFO,
2277             TYPE_CHAM  = 'ELGA_VARI_R',
2278             OPERATION = 'ASSE',
2279             PROL_ZERO = 'OUI',
2280             MODELE    = self.NEW_MODELE,
2281             ASSE      = _F(
2282                 TOUT = 'OUI',
2283                 CHAM_GD = __ECRGN,
2284                 NOM_CMP = tupVar,
2285                 NOM_CMP_RESU = tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'])))
2286 # AA        dicAffe.append({'CHAM_GD' : __EFFG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
2287         dicAffe.append({'CHAM_GD' : __EFFG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER, 'CARA_ELEM' : self.CARA_ELEM, 'INST': resu.LIST_PARA()['INST'][i]})
2288         # dicAffe2.append({'CHAM_GD' : __EPSG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
2289 # AA        dicAffe3.append({'CHAM_GD' : __ECRG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
2290         dicAffe3.append({'CHAM_GD' : __ECRG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER, 'CARA_ELEM' : self.CARA_ELEM, 'INST': resu.LIST_PARA()['INST'][i]})
2291         DETRUIRE(CONCEPT=dicDetr, INFO=1)
2292         resu = CREA_RESU(reuse=resu,
2293             OPERATION = 'AFFE',
2294             TYPE_RESU = 'EVOL_NOLI',
2295             NOM_CHAM  = 'SIEF_ELGA',
2296             AFFE = dicAffe,
2297             )
2298         # resu = CREA_RESU(reuse=resu,
2299             # OPERATION = 'AFFE',
2300             # TYPE_RESU = 'EVOL_NOLI',
2301             # NOM_CHAM  = 'EPSI_ELGA_DEPL',
2302             # AFFE = dicAffe2)
2303         resu = CREA_RESU(reuse=resu,
2304             OPERATION = 'AFFE',
2305             TYPE_RESU = 'EVOL_NOLI',
2306             NOM_CHAM  = 'VARI_ELGA',
2307             AFFE = dicAffe3,
2308             )
2309
2310     DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');
2311
2312     os.remove(fort)
2313
2314 #-----------------------------------------------------------------------
2315   def lancer_calcul(self,fichier_med='auto'):
2316
2317      fichier_epx = self.nom_fichiers['COMMANDE']
2318      EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; %s -usetmpdir %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd),
2319                    CODE_RETOUR_MAXI=-1,
2320                    INFO=2)
2321
2322
2323 #------------------------------------------------------------------------
2324 #----------------------------- FIN class EUROPLEXUS ---------------------
2325 #------------------------------------------------------------------------
2326
2327
2328 #------------------------------------------------------------------------
2329 #----------------------------- class POUTRE -----------------------------
2330 #------------------------------------------------------------------------
2331
2332 class POUTRE:
2333   def __init__(self,MAILLAGE,CARA_ELEM):
2334
2335     # recuperer les infos du maillage sous format python
2336     self.MApyt = MAIL_PY()
2337     self.MApyt.FromAster(MAILLAGE)
2338     self.CARA_ELEM = CARA_ELEM
2339     # un dictionnaire stockant tous orientations definis dans AFF_CARA_ELEM
2340     self.dic_gma = self.orientation_cara_elem()
2341
2342 #------------------------------------------------------------------------
2343   def getvecteurs(self,groupes_poutres,verif='non'):
2344     vecteurs = {}
2345     ig = 0
2346     message = 0
2347     for gr in groupes_poutres :
2348       ig += 1
2349       if not self.dic_gma.has_key(gr): self.dic_gma[gr] = {'ANGL_VRIL':0.0}
2350       vecteurs[gr] = self.get_vecty_group_ma(gr)
2351       if verif == 'oui':
2352         if ig > 1 :
2353           if not vecteurs_egaux(vecteurs[gr],vect_old) : message = 1
2354         vect_old = vecteurs[gr]
2355
2356     if message : UTMESS('F','PLEXUS_10',valk=groupes_poutres)
2357
2358     return vecteurs
2359
2360 #------------------------------------------------------------------------
2361   def orientation_cara_elem(self,):
2362
2363     dic_gma = {}
2364     etapes = self.CARA_ELEM.etape.valeur
2365
2366     if not etapes.has_key('ORIENTATION') : return dic_gma
2367
2368     orientation = etapes['ORIENTATION']
2369     try :
2370       test = orientation [0]
2371     except :
2372       orientation  = [orientation]
2373
2374     for ll in orientation  :
2375       cara = ll['CARA']
2376       if cara in ['ANGL_VRIL','ANGL_NAUT','VECT_Y'] :
2377         if ll.has_key('GROUP_MA') :
2378           group_ma = ll['GROUP_MA']
2379           if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,)
2380           a = ll['VALE']
2381           for gr in group_ma:
2382             if not dic_gma.has_key(gr): dic_gma[gr] = {}
2383             dic_gma[gr][cara] = a
2384
2385     for gr in dic_gma.keys() :
2386       if not dic_gma[gr].has_key('VECT_Y'):
2387         if not dic_gma[gr].has_key('ANGL_VRIL') : dic_gma[gr]['ANGL_VRIL'] = 0.0
2388         if dic_gma[gr].has_key('ANGL_NAUT'):
2389           if len(dic_gma[gr]['ANGL_NAUT']) == 2 :
2390             dic_gma[gr]['ANGL_NAUT'] = list(dic_gma[gr]['ANGL_NAUT']) + [dic_gma[gr]['ANGL_VRIL']]
2391
2392     return(dic_gma)
2393
2394 #------------------------------------------------------------------------
2395   def get_vecty_group_ma(self,group_ma):
2396
2397     #if debug: print '*'*10
2398     #if debug: print 'Test de group_ma',group_ma
2399     #if debug: print '*'*10
2400
2401     message = 0
2402
2403     if self.dic_gma[group_ma].has_key('VECT_Y') : return self.dic_gma[group_ma]['VECT_Y']
2404
2405     if not self.dic_gma[group_ma].has_key('ANGL_NAUT'):calcul_angle = 1
2406     else: calcul_angle = 0
2407
2408     mailles = self.MApyt.gma[string.rstrip(group_ma)]
2409
2410     for imaille in range(len(mailles)):
2411       maille = mailles[imaille]
2412       if calcul_angle:
2413         alpha,beta = self.calcul_angles_naut(maille)
2414         angl = [alpha,beta,self.dic_gma[group_ma]['ANGL_VRIL']]
2415       else:
2416         angl = self.dic_gma[group_ma]['ANGL_NAUT']
2417
2418       vect_y = self.angle2vecty(angl)
2419       if imaille > 1 :
2420         if not vecteurs_egaux(vect_y0,vect_y) : message = 1
2421       vect_y0 = vect_y
2422
2423     self.dic_gma[group_ma]['VECT_Y'] = vect_y
2424
2425     if message :
2426       #if debug: print 'group_ma',group_ma
2427       UTMESS('F','PLEXUS_11',valk=group_ma)
2428
2429     return vect_y
2430
2431 #------------------------------------------------------------------------
2432   def angle2vecty(self,angl):
2433     #transformer en rd
2434     for iangl in range(len(angl)):
2435       angl[iangl] = N.pi*angl[iangl]/180.
2436
2437     cosa = math.cos( angl[0] )
2438     sina = math.sin( angl[0] )
2439     cosb = math.cos( angl[1] )
2440     sinb = math.sin( angl[1] )
2441     cosg = math.cos( angl[2] )
2442     sing = math.sin( angl[2] )
2443     vect = [ sing*sinb*cosa - cosg*sina , cosg*cosa + sing*sinb*sina , sing*cosb ]
2444     for ii in range(len(vect)):
2445       if abs(vect[ii]) <= tst : vect[ii] = 0.0
2446     vect = N.array(vect)
2447     vect = vect/norme(vect)
2448     return vect
2449
2450 #------------------------------------------------------------------------
2451   def get_coor_nodes_maille(self,maille):
2452     node1,node2 = self.MApyt.co[maille]
2453     coor1 = self.MApyt.cn[node1]
2454     coor2 = self.MApyt.cn[node2]
2455     return [coor1,coor2]
2456
2457 #------------------------------------------------------------------------
2458   def calcul_angles_naut(self,maille):
2459
2460     # Angles directeurs d'une poutre (nautiques)
2461
2462     a,b = self.get_coor_nodes_maille(maille)
2463
2464     gx = [ b[0]-a[0] , b[1]-a[1] , b[2]-a[2] ]
2465
2466     if( (abs(gx[1]) < tst)  and (abs(gx[0]) <= tst) ):
2467       alpha = 0.0
2468     else:
2469       alpha = math.atan2(gx[1],gx[0])
2470
2471     p  = math.sqrt( gx[0]*gx[0] + gx[1]*gx[1] )
2472     if( (abs(gx[2]) < tst ) and (abs(p) <=tst) ):
2473       beta = 0.0
2474     else:
2475       beta  = -math.atan2(gx[2],p)
2476
2477     # alpha et Beta en degre
2478     alpha = alpha*180./math.pi
2479     beta = beta*180./math.pi
2480
2481     return alpha,beta
2482
2483 #------------------------------------------------------------------------
2484 #----------------------------- FIN class POUTRE -------------------------
2485 #------------------------------------------------------------------------
2486
2487
2488 #------------------------------------------------------------------------
2489 #----------------------------- class DKT --------------------------------
2490 #------------------------------------------------------------------------
2491
2492 class DKT:
2493
2494   def __init__(self,MAILLAGE):
2495
2496     self.MAILLAGE = MAILLAGE
2497     # recuperer les infos du maillage sous format python
2498     self.MApyt = MAIL_PY()
2499     self.MApyt.FromAster(MAILLAGE)
2500
2501   def aster2epx(self,groups):
2502
2503     # initialisations du dic contenant les mailles de tria3 et quad4
2504     dic_groups = {}
2505     for cle in ['TRIA3','QUAD4']:
2506       dic_groups[cle] = []
2507     # placer les mailles dans le champ associe
2508     for gr in groups:
2509       mailles = self.MApyt.gma[string.rstrip(gr)]
2510       for maille in mailles:
2511         code_maille = self.MApyt.tm[maille]
2512         type_maille = self.MApyt.nom[code_maille]
2513         maille_initiale = string.rstrip(self.MApyt.correspondance_mailles[maille])
2514         if not maille_initiale in dic_groups[type_maille] :
2515           dic_groups[type_maille].append(maille_initiale)
2516
2517     # creer le mot-cle facteur permettant de creer les groupes de mailles associes au TRIA3 et QUAD4
2518     crea_group_ma = []
2519     # dictionnair contenant les noms des groups qui vont etre creer au besoin
2520     nom_groups = {}
2521     for cle in dic_groups.keys() :
2522       if len(dic_groups[cle]) > 0 :
2523         crea_group_ma.append({'MAILLE':dic_groups[cle],'NOM':cle})
2524         nom_groups[cle] = [cle]
2525       else:
2526         nom_groups[cle] = []
2527     # ce n'est pas necessaire de creer les group_ma si on n'a pas de quad4
2528     if len(dic_groups['QUAD4']) >0:
2529
2530       #global DEFI_GROUP
2531
2532       DEFI_GROUP(reuse         = self.MAILLAGE,
2533                  MAILLAGE      = self.MAILLAGE,
2534                  CREA_GROUP_MA = crea_group_ma,
2535                 );
2536
2537     else :
2538       # on affecte au TRIA les groupes deja fournis en argument
2539       nom_groups['TRIA3'] = groups
2540
2541     return nom_groups
2542
2543 #------------------------------------------------------------------------
2544 #----------------------------- FIN class DKT ----------------------------
2545 #------------------------------------------------------------------------