Aster/Cata/Utilitai/partition.py

   1 #@ MODIF partition Utilitai  DATE 10/02/2005   AUTEUR ASSIRE A.ASSIRE
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2004  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 import aster
  23 import string, os, time, sys, UserList, types
  24 import Numeric as N
  25
  26 from Accas import _F
  27 from Noyau.N_utils import AsType
  28
  29 # ------------------------------------------------------------------ #
  30
  31 def enleve_doublons_liste(liste):
  32   """ A partir d une liste qui peut contenir des doublons, on renvoie une liste sans
  33       doublons (et qui reviendra triée)
  34   """
  35
  36   """ Au cas ou ca ne serait pas deja un vecteur numpy """  # Exemple
  37   liste=N.sort(N.array(liste,copy=0))                 # [1, 2, 2, 3, 3, 4, 5]
  38   liste_diff=liste[1:]-liste[:-1]                     # [1, 0, 1, 0, 1, 1]
  39   liste_temp=N.nonzero(liste_diff)                    # [0, 2, 4, 5]
  40   liste_indice=N.zeros(liste_temp.shape[0]+1)
  41   liste_indice[0]=0
  42   liste_indice[1:]=liste_temp+1                       # [0, 1, 3, 5, 6]
  43   liste2=N.take(liste,liste_indice)                   # [1, 2, 3, 4, 5]
  44   return liste2
  45
  46
  47 # ============================================================================ #
  48
  49
  50 class CONNEC(UserList.UserList) :
  51   """
  52     Connectivite : sequence mutable de sequences de noeuds
  53     Pour l'instant, on s'appuie sur une liste de liste.
  54   """
  55
  56   def __init__(self,nma) :
  57
  58     UserList.UserList.__init__(self,[None]*nma)
  59
  60
  61   def Index(self) :
  62     """
  63       Retourne la connectivite sous forme de deux vecteurs numpy :
  64         ind -> tableau des index (y compris le n+1 eme)
  65         noe -> tableau des listes de noeuds
  66     """
  67
  68     # Dimension des deux vecteurs
  69     nma  = len(self)
  70     ltot = N.reduce(lambda x,y : x+len(y), self,0)
  71     ind = N.zeros(nma+1,Int)
  72     noe = N.zeros(ltot,Int)
  73
  74     # Construction des vecteurs
  75     ind[0] = 0
  76     for i in range(nma) :
  77       m = self[i]
  78       ind[i+1] = ind[i] + len(m)
  79       noe[ind[i]:ind[i+1]] = N.array(m)
  80
  81     return ind,noe
  82
  83
  84 # ============================================================================ #
  85 # ============================================================================ #
  86
  87 class MAIL_PY :
  88
  89   """
  90     SD PYTHON  MAILLAGE
  91     La numeration est 0..N-1 pour les noeuds et 0..M-1 pour les mailles
  92   """
  93
  94   def __init__(self,nno=0,nma=0) :
  95
  96     self.cn  = N.zeros((nno,3),N.Float)
  97     self.tm  = N.zeros(nma,N.Int)
  98     self.co  = CONNEC(nma)
  99     self.gma = {}
 100     self.gno = {}
 101     self.indice_noeuds = N.arange(nno)
 102
 103     self.correspondance_noeuds = []
 104     self.correspondance_mailles = []
 105
 106     try:
 107       import aster
 108       nom_mailles = (None,) + string.strip(aster.getvectjev('&CATA.TM.NOMTM'))
 109     except:
 110       nom_mailles = (None,
 111       'POI1',   'SEG2',   'SEG22',  'SEG3',   'SEG33',  'SEG4',   'TRIA3',
 112       'TRIA33', 'TRIA6',  'TRIA66', 'TRIA7',  'QUAD4',  'QUAD44', 'QUAD8',
 113       'QUAD88', 'QUAD9',  'QUAD99', 'TETRA4', 'TETRA10','PENTA6', 'PENTA15',
 114       'PYRAM5', 'PYRAM13','HEXA8',  'HEXA20', 'HEXA27', 'TR3QU4', 'QU4TR3',
 115       'TR6TR3', 'TR3TR6', 'TR6QU4', 'QU4TR6', 'TR6QU8', 'QU8TR6', 'TR6QU9',
 116       'QU9TR6', 'QU8TR3', 'TR3QU8', 'QU8QU4', 'QU4QU8', 'QU8QU9', 'QU9QU8',
 117       'QU9QU4', 'QU4QU9', 'QU9TR3', 'TR3QU9', 'SEG32',  'SEG23' )
 118
 119     dic_mailles = {}
 120     for i in range(len(nom_mailles)) :
 121       dic_mailles[nom_mailles[i]] = i
 122
 123     self.nom = nom_mailles
 124     self.dic = dic_mailles
 125
 126     try:
 127       psyco.bind(self.FromAster)
 128     except: pass
 129
 130
 131 # -------------------------------------------------------------
 132
 133   def get_connexite(self, nom, nma):
 134     co=CONNEC(nma)
 135     dico_connexite = aster.getcolljev(nom)
 136     for element in dico_connexite.keys() :
 137       co[int(element)-1] = (N.array(dico_connexite[element])-1)
 138     return co
 139
 140
 141   def get_coordonnees_noeuds(self, nom, nombre_noeuds):
 142     coordonnees_noeuds = aster.getvectjev(nom)
 143     coordonnees_noeuds = N.array(coordonnees_noeuds)
 144     coordonnees_noeuds.shape = (nombre_noeuds,3)
 145     cn = coordonnees_noeuds
 146     return cn
 147
 148
 149 # -------------------------------------------------------------
 150
 151   def FromAster(self,nom) :
 152
 153     # On accepte le concept Aster ou bien la chaine texte de son nom
 154     if type(nom)!=types.StringType:
 155       nom_maillage = nom.nom
 156     else:
 157       nom_maillage = nom
 158
 159     nom_maillage=string.ljust(nom_maillage,8)
 160
 161     # recuperation de la taille
 162     self.dime_maillage = aster.getvectjev(nom_maillage+'.DIME')
 163     nombre_noeuds      = self.dime_maillage[0]
 164     nombre_mailles     = self.dime_maillage[2]
 165
 166     # coordonnees des noeuds
 167     self.cn = self.get_coordonnees_noeuds(nom_maillage+'.COORDO    .VALE', nombre_noeuds)
 168
 169     # type de maille
 170     self.tm = N.array(aster.getvectjev(nom_maillage+'.TYPMAIL'))
 171
 172     # connexite
 173     self.co = self.get_connexite(nom_maillage+'.CONNEX', nombre_mailles)
 174
 175     self.indice_noeuds=N.arange(nombre_noeuds)
 176
 177     # groupe de noeuds
 178     Lno_groupno_tot = aster.getcolljev(nom_maillage+'.GROUPENO')
 179
 180     Lno_groupno={}
 181     for key in Lno_groupno_tot :
 182       # Tolerance car parfois defi_group crée des groupes nuls à clé entiere
 183       try:
 184         Lno_groupno[key.strip()]=N.array(Lno_groupno_tot[key])-1
 185       except: pass
 186     self.gno=Lno_groupno
 187
 188     # groupe de mailles
 189     Lma_groupma_tot     = aster.getcolljev(nom_maillage+'.GROUPEMA')
 190     Lma_groupma={}
 191     for key in Lma_groupma_tot :
 192       Lma_groupma[key.strip()]=N.array(Lma_groupma_tot[key])-1
 193     self.gma=Lma_groupma
 194
 195     del(Lma_groupma_tot)
 196
 197     # listes de correspondance entre Aster et Mail-Py
 198     self.correspondance_noeuds  = aster.getvectjev(nom_maillage+'.NOMNOE')
 199     self.correspondance_mailles = aster.getvectjev(nom_maillage+'.NOMMAI')
 200
 201
 202 # -------------------------------------------------------------
 203
 204   def ToAster(self) :
 205
 206     try:
 207       INFO_EXEC_ASTER = self.jdc.get_cmd('INFO_EXEC_ASTER')
 208       DETRUIRE        = self.jdc.get_cmd('DETRUIRE')
 209       LIRE_MAILLAGE   = self.jdc.get_cmd('LIRE_MAILLAGE')
 210     except:
 211       try:
 212         from Cata.cata import INFO_EXEC_ASTER
 213         from Cata.cata import DETRUIRE
 214         from Cata.cata import LIRE_MAILLAGE
 215       except:
 216         print "\n\nERREUR : il faut lancer ce programme depuis Aster pour pouvoir \ngénérer un maillage Aster.\n\n"
 217         sys.exit(1)
 218
 219     # Recuperation d'une unité logique libre
 220     _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
 221     ul1=_UL['UNITE_LIBRE',1]
 222     DETRUIRE(CONCEPT=(_F(NOM=_UL),), INFO=1)
 223
 224     # Sauvegarde du maillage dans un fichier .mail
 225     fichier = 'fort.'+str(ul1)
 226     f = open(fichier, 'w')
 227     f.write( self.Voir_Mail() )
 228     f.close()
 229
 230     # Récupération des concepts Aster présents dans la base
 231 # Note AA : ne marche pas encore bien :
 232 # Limitation : ne gere qu'un seul maillage genere par ToAster
 233 #
 234 #     nom='_MSH'
 235 #     try:
 236 #       self.jdc_recupere=CONTEXT.get_current_step()
 237 #       t_maillage=[]
 238 #       for i in self.jdc_recupere.sds_dict.keys( ):
 239 #         if self.jdc_recupere.sds_dict[i].__class__.__name__ == 'maillage_sdaster':
 240 #           if (mail[0:4]==nom):
 241 #             t_maillage.append( i )
 242 #
 243 #       num=len(_lst)+1
 244 #     except:
 245 #       num=0
 246
 247     # Lecture de ce fichier .mail pour l'injecter dans l'espace Aster
 248     _SMESH_ = LIRE_MAILLAGE(UNITE = ul1)
 249
 250     return(_SMESH_)
 251
 252 # -------------------------------------------------------------
 253
 254   def __str__(self) :
 255     return self.Voir_Mail()
 256
 257 # -------------------------------------------------------------
 258
 259   def Voir_Mail(self) :
 260     """
 261       Impression au format ASTER
 262     """
 263
 264     l = []
 265     l.append('TITRE')
 266     l.append('%  CLASSE PY_MAIL -> MAIL')
 267     l.append('FINSF')
 268     l.append('%')
 269
 270     (nno,ndim) = self.cn.shape
 271
 272
 273     # Coordonnees des noeuds
 274     l.append('COOR_3D')
 275
 276     # Si le maillage initial ne provient pas d'Aster
 277     if len(self.correspondance_noeuds) == 0:
 278       for i in range(nno) :
 279         ch = 'N'+repr(i)+'  '+`self.cn[i,0]` + '  ' + `self.cn[i,1]` + '  ' + `self.cn[i,2]`
 280 #        ch = 'N'+repr(i+1)+'  '+`self.cn[i,0]` + '  ' + `self.cn[i,1]` + '  ' + `self.cn[i,2]`
 281         l.append(ch)
 282
 283     # Si le maillage initial provient d'Aster
 284     else:
 285       for i in range(nno) :
 286         ch = self.correspondance_noeuds[i]+'  '+`self.cn[i,0]` + '  ' + `self.cn[i,1]` + '  ' + `self.cn[i,2]`
 287 #        ch = 'N'+repr(i+1)+'  '+`self.cn[i,0]` + '  ' + `self.cn[i,1]` + '  ' + `self.cn[i,2]`
 288         l.append(ch)
 289
 290     # Connectivité des mailles
 291     ind = N.argsort(self.tm)
 292     ty = 0
 293
 294     # Si le maillage initial ne provient pas d'Aster
 295     if len(self.correspondance_mailles) == 0:
 296       for m in ind :
 297         if self.tm[m] <> ty :
 298           l.append('FINSF') ; l.append('%')
 299           ty = self.tm[m]
 300           l.append(self.nom[ty])
 301         ch = 'M'+`m`+'  '
 302 #        ch = 'M'+`m+1`+'  '
 303         for n in self.co[m] :
 304           ch = ch + 'N'+`n` + ' '
 305 #          ch = ch + 'N'+`n+1` + ' '
 306         l.append(ch)
 307
 308     # Si le maillage initial provient d'Aster
 309     else:
 310       for m in ind :
 311         if self.tm[m] <> ty :
 312           l.append('FINSF') ; l.append('%')
 313           ty = self.tm[m]
 314           l.append(self.nom[ty])
 315         ch = self.correspondance_mailles[m]+'  '
 316 #        ch = 'M'+`m+1`+'  '
 317         for n in self.co[m] :
 318           ch = ch + self.correspondance_noeuds[n] + ' '
 319 #          ch = ch + 'N'+`n+1` + ' '
 320         l.append(ch)
 321
 322     l.append('FINSF') ; l.append('%')
 323
 324
 325     # Group_ma et Group_no
 326     entete = ['GROUP_MA','GROUP_NO']
 327     d_gp   = [self.gma,self.gno]
 328     pref   = ['M','N']
 329
 330     # Si le maillage initial ne provient pas d'Aster
 331     if len(self.correspondance_mailles) == 0:
 332
 333       for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] :
 334         for gp in d_gp :
 335          if len(d_gp[gp])>0:  # On ne prend en compte que les group_* non vides
 336           l.append(entete)
 337           l.append('  ' + gp)
 338           ch = ' '
 339           i=0
 340           for o in d_gp[gp]:
 341             i+=1  # on ne met que 8 mailles sur une meme ligne
 342             if (len(ch) > 60 or i>7):
 343               l.append(ch)
 344               ch = ' '
 345               i=0
 346             ch = ch + prefixe + `o` + ' '
 347           l.append(ch)
 348           l.append('FINSF') ; l.append('%')
 349
 350     # Si le maillage initial provient d'Aster
 351     else:
 352
 353       for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] :
 354         for gp in d_gp :
 355          if len(d_gp[gp])>0:  # On ne prend en compte que les group_* non vides
 356           l.append(entete)
 357           l.append('  ' + gp)
 358           ch = ' '
 359           i=0
 360           for o in d_gp[gp]:
 361             i+=1  # on ne met que 8 mailles sur une meme ligne
 362             if (len(ch) > 60 or i>7):
 363               l.append(ch)
 364               ch = ' '
 365               i=0
 366 #            ch = ch + prefixe + `o` + ' '
 367             if prefixe=='M':
 368               ch = ch + self.correspondance_mailles[o] + ' '
 369             else:
 370               ch = ch + self.correspondance_noeuds[o] + ' '
 371           l.append(ch)
 372           l.append('FINSF') ; l.append('%')
 373
 374     # Fin
 375     l.append('FIN\n')
 376     return string.join(l,'\n')
 377
 378
 379
 380
 381 # ============================================================================ #
 382 # ============================================================================ #
 383
 384 class PARTITION:
 385
 386   def __init__(self, jdc=None ,nb=0):
 387
 388     self.jdc = jdc
 389
 390     self.fichier_out        = ''
 391     self.liste_mailles      = N.array( [] )
 392     self.liste_sd           = N.array( [] )
 393     self.liste_mailles_bord = []
 394     self.liste_sd_bord      = []
 395
 396     self.MAILLAGE_Python    = None
 397
 398     self.RELATIONS      = { 'C_plus' : None,
 399                             'C_moins': None,
 400                             'nr': 0 }
 401
 402     self.ASTER          = { 'MAILLAGE'        : None,
 403                             'MODELE'          : None,
 404                             'GROUP_MA'        : None,
 405                             'GROUP_MA_BORD'   : None,
 406                             'DICO_SD_MAILLES' : None,
 407                              }
 408
 409     self.OPTIONS        = { 'NB_PART'     : '',
 410                             'ALGO'        : '',
 411                             'INFO'        : '',
 412                             'rep_metis'   : aster.repout(),
 413                             'exe_metis'   : aster.repout() + 'pmetis',
 414                             'fichier_in'  : 'fort.66',
 415                             'fichier_out' : 'fort.68',
 416                             'elimine_bords': 'OUI',
 417                              }
 418
 419     self.Creation_Dico_Correspondance_Type_Maille()
 420
 421
 422
 423 # ---------------------------------------------------------------------------- #
 424
 425   def __str__(self) :
 426     """
 427       Impression du contenu de la partition
 428     """
 429     l = []
 430     l.append( 'Contenu de la partition :' )
 431     l.append( '-------------------------' )
 432     try: l.append( '- Maillage       : ' + str(self.ASTER['MAILLAGE'].nom) )
 433     except: pass
 434     try: l.append( '- Modele         : ' + str(self.ASTER['MODELE'].nom) )
 435     except: pass
 436     l.append( '- Nb part        : ' + str(self.OPTIONS['NB_PART']) )
 437     l.append( '- Niveau INFO    : ' + str(self.OPTIONS['INFO']) )
 438     l.append( '- Liste group_ma : ' + str(self.ASTER['GROUP_MA']) )
 439
 440     return string.join(l,'\n')
 441
 442 # ---------------------------------------------------------------------------- #
 443
 444   def Partitionne_Aster(self, MAILLAGE, NB_PART, MODELE=None, METHODE=None, LOGICIEL=None, INFO=1):
 445
 446     self.t00 = time.clock()
 447
 448     self.OPTIONS['INFO'] = INFO
 449
 450     if MODELE:
 451       # Recuperation de la liste des mailles à perndre en compte
 452       self.ASTER['MODELE'] = MODELE
 453       self.ASTER['MAILLAGE'] = MAILLAGE
 454       _LST_MA = self.Modele_to_Liste_Mailles(MODELE)
 455
 456     elif MAILLAGE:
 457       self.ASTER['MAILLAGE'] = MAILLAGE
 458       _LST_MA = None
 459
 460
 461     # Creation du maillage Python correspondant au maillage Aster
 462     MAILLAGE_Python = MAIL_PY()
 463     MAILLAGE_Python.FromAster(MAILLAGE.nom)
 464
 465     # Partitionne le maillage Python avec la liste de mailles _LST_MA
 466     self.Partitionne_Maillage(MAILLAGE_Python, NB_PART, MAILLE=_LST_MA, METHODE=METHODE, LOGICIEL=LOGICIEL, INFO=INFO)
 467
 468     return
 469
 470
 471 # ---------------------------------------------------------------------------- #
 472
 473   def Partitionne_Maillage(self, MAILLAGE_Python, NB_PART, MAILLE=None, METHODE=None, LOGICIEL=None, INFO=1):
 474
 475     self.t00 =  time.clock()
 476
 477     if METHODE:
 478       self.OPTIONS['exe_metis'] = aster.repout() + string.lower(METHODE)
 479     elif LOGICIEL:
 480       self.OPTIONS['exe_metis'] = LOGICIEL
 481
 482     self.OPTIONS['NB_PART'] = NB_PART
 483     self.OPTIONS['INFO']    = INFO
 484     self.MAILLAGE_Python    = MAILLAGE_Python
 485
 486     exe_metis = self.OPTIONS['exe_metis']
 487     f_metis   = self.OPTIONS['fichier_in']
 488     fw_metis  = self.OPTIONS['fichier_out']
 489
 490     _LST_MA = MAILLE
 491
 492     # On initialise la connectivité et la connectivité inverse des aretes
 493     self.MAILLAGE_Python.ca = {}
 494     self.MAILLAGE_Python.cia = {}
 495
 496     _DIM = self.MAILLAGE_Python.dime_maillage[5]
 497     _LST_TMA = self.MAILLAGE_Python.tm
 498
 499     if self.OPTIONS['INFO']>=5:
 500       print 'cn=', self.MAILLAGE_Python.cn
 501       print 'tm=', self.MAILLAGE_Python.tm
 502       print 'co=', self.MAILLAGE_Python.co
 503       print 'gma=', self.MAILLAGE_Python.gma
 504       print 'gno=', self.MAILLAGE_Python.gno
 505       print 'dim=', self.MAILLAGE_Python.dime_maillage
 506     if self.OPTIONS['INFO']>=5: print '_LST_MA=', _LST_MA
 507
 508
 509     # Elimination des mailles de bords
 510     if self.OPTIONS['elimine_bords']!='NON':
 511
 512       # Liste des mailles à prendre en compte : dimension _DIM
 513       _D_DIM_MAILLES = self.Creation_Listes_Mailles_Par_Dim(self.MAILLAGE_Python.tm, _LST_MA=_LST_MA)
 514
 515       # Connectivité et connectivité inverse sur les bords
 516       self.Connectivite_Aretes()
 517
 518       self.liste_mailles = _D_DIM_MAILLES[ _DIM ]
 519
 520       # Pour prendre en compte des mélanges d'elements de dimension differente
 521       _LST, _LST_BD = self.Elimination_Mailles_de_bords(MAILLAGE_Python, _D_DIM_MAILLES, _DIM)
 522       self.liste_mailles = N.concatenate( (self.liste_mailles,N.array(_LST)) )
 523
 524       if self.OPTIONS['INFO']>=5:
 525         print '_LST_BD=',_LST_BD
 526         print '_LST=',_LST
 527
 528     else:
 529       self.liste_mailles = _LST_MA
 530
 531
 532     # Restriction des connectivités aux mailles à prendre en compte
 533     self.Connectivite_Aretes(OPTION='all', _LST_OK=self.liste_mailles)
 534
 535     # Creation de l'arbre de connectivité des bords
 536     self.Creation_Graphe()
 537
 538     # Reduction de l'arbre de connectivité des bords
 539     _nb = self.Reduction_Graphe(_DIM)
 540
 541     # Ecriture du fichier pour Metis/Chaco/Jostle
 542     _D_CORRES = self.Ecrire_Graphe(f_metis, _nb)
 543
 544     # Lancement de metis sur le fichier fort.UL (production de fort.UL.part.N)
 545     txt = exe_metis + ' ' + f_metis + ' ' + str(NB_PART)
 546     print 'Commande : ',txt
 547     os.system( txt )
 548
 549     # Lecture du fichier resultant de Metis
 550     self.fichier_out = f_metis + '.part.' + str(NB_PART)
 551     self.liste_sd = self.Lecture_fichier_sdd(self.fichier_out, self.liste_mailles)
 552
 553     # Traitement des mailles de bords (on les reinjecte dans un SD)
 554     if self.OPTIONS['elimine_bords']!='NON':
 555       self.Affectation_Mailles_de_bords(_LST_BD, _DIM)
 556
 557     t1 = time.clock()
 558     print "--- FIN PARTITIONNEMENT : ", t1 - self.t00
 559
 560     return
 561
 562
 563
 564 # ---------------------------------------------------------------------------- #
 565
 566   def Creation_Dico_Correspondance_Type_Maille(self):
 567
 568     # TYPE_ELEM : CF. &CATA.TM
 569     #   1 - >POI1    <>SEG2    <>SEG22   <>SEG3    <>SEG33   <>SEG4    <>TRIA3   <
 570     #   8 - >TRIA33  <>TRIA6   <>TRIA66  <>TRIA7   <>QUAD4   <>QUAD44  <>QUAD8   <
 571     #  15 - >QUAD88  <>QUAD9   <>QUAD99  <>TETRA4  <>TETRA10 <>PENTA6  <>PENTA15 <
 572     #  22 - >PYRAM5  <>PYRAM13 <>HEXA8   <>HEXA20  <>HEXA27  <>TR3QU4  <>QU4TR3  <
 573     #  29 - >TR6TR3  <>TR3TR6  <>TR6QU4  <>QU4TR6  <>TR6QU8  <>QU8TR6  <>TR6QU9  <
 574     #  36 - >QU9TR6  <>QU8TR3  <>TR3QU8  <>QU8QU4  <>QU4QU8  <>QU8QU9  <>QU9QU8  <
 575     #  43 - >QU9QU4  <>QU4QU9  <>QU9TR3  <>TR3QU9  <>SEG32   <>SEG23   <
 576
 577     # Creation du dictionnaire des correspondance type_maille -> liste des aretes
 578     maille2aretes={}
 579     # POI
 580     maille2aretes[1]  = [ ]
 581     # SEG
 582     maille2aretes[2]  = [ (0,1) ]
 583     maille2aretes[3]  = maille2aretes[4] = maille2aretes[5] = maille2aretes[6] = maille2aretes[2]
 584     # TRIA
 585     maille2aretes[7]  = [ (0,1),(1,2),(0,2) ]
 586     maille2aretes[8]  = maille2aretes[9] = maille2aretes[10] = maille2aretes[11] = maille2aretes[7]
 587     # QUAD
 588     maille2aretes[12] = [ (0,1),(1,2),(2,3),(0,3) ]
 589     maille2aretes[13] = maille2aretes[14] = maille2aretes[15] = maille2aretes[16] = maille2aretes[17] = maille2aretes[12]
 590     # TETRA
 591     maille2aretes[18] = [ (0,1,2),(0,1,3),(0,2,3),(1,3,2) ]
 592     maille2aretes[19] = maille2aretes[18]
 593     # PENTA
 594     maille2aretes[20] = [ (0,1,2),(3,4,5),(0,2,5,3),(0,1,4,3),(2,1,4,5) ]
 595     maille2aretes[21] = maille2aretes[20]
 596     # PYRAM
 597     maille2aretes[22] = [ (0,1,4),(1,2,4),(2,3,4),(3,0,4),(0,1,2,3) ]
 598     maille2aretes[23] = maille2aretes[22]
 599     # HEXA
 600     maille2aretes[24] = [ (0,1,2,3), (4,5,6,7), (1,2,6,5), (2,3,7,6), (7,4,0,3), (4,5,1,0) ]
 601     maille2aretes[25] = maille2aretes[26] =  maille2aretes[24]
 602
 603
 604     # dictionnaire de correspondance entre type_maille -> nb noeud (maille linéaire)
 605     maille2nb={}
 606     # POI
 607     maille2nb[1]  = 1
 608     # SEG
 609     maille2nb[2]  = 2
 610     maille2nb[3]  = maille2nb[4] = maille2nb[5] = maille2nb[6] = maille2nb[2]
 611     # TRIA
 612     maille2nb[7]  = 3
 613     maille2nb[8]  = maille2nb[9] = maille2nb[10] = maille2nb[11] = maille2nb[7]
 614     # QUAD
 615     maille2nb[12] = 4
 616     maille2nb[13] = maille2nb[14] = maille2nb[15] = maille2nb[16] = maille2nb[17] = maille2nb[12]
 617     # TETRA
 618     maille2nb[18] = 4
 619     maille2nb[19] = maille2nb[18]
 620     # PENTA
 621     maille2nb[20] = 5
 622     maille2nb[21] = maille2nb[20]
 623     # PYRAM
 624     maille2nb[22] = 5
 625     maille2nb[23] = maille2nb[22]
 626     # HEXA
 627     maille2nb[24] = 6
 628     maille2nb[25] = maille2nb[26] =  maille2nb[24]
 629
 630
 631     # dictionnaire de correspondance entre type_maille -> dimension
 632     maille2dim = {}
 633     # POI
 634     maille2dim[1]  = 0
 635     # SEG
 636     maille2dim[2]  = 1
 637     maille2dim[3]  = maille2dim[4] = maille2dim[5] = maille2dim[6] = maille2dim[2]
 638     # TRIA
 639     maille2dim[7]  = 2
 640     maille2dim[8]  = maille2dim[9] = maille2dim[10] = maille2dim[11] = maille2dim[7]
 641     # QUAD
 642     maille2dim[12] = 2
 643     maille2dim[13] = maille2dim[14] = maille2dim[15] = maille2dim[16] = maille2dim[17] = maille2dim[12]
 644     # TETRA
 645     maille2dim[18] = 3
 646     maille2dim[19] = maille2dim[18]
 647     # PENTA
 648     maille2dim[20] = 3
 649     maille2dim[21] = maille2dim[20]
 650     # PYRAM
 651     maille2dim[22] = 3
 652     maille2dim[23] = maille2dim[22]
 653     # HEXA
 654     maille2dim[24] = 3
 655     maille2dim[25] = maille2dim[26] =  maille2dim[24]
 656
 657     # On stocke les dictionnaires
 658     self.maille2aretes = maille2aretes
 659     self.maille2nb     = maille2nb
 660     self.maille2dim    = maille2dim
 661
 662     return
 663
 664
 665 # ---------------------------------------------------------------------------- #
 666
 667   def Modele_to_Liste_Mailles(self, MODELE):
 668
 669     nommod = string.ljust(MODELE.nom,8)
 670     _DIC_MA  = aster.getcolljev(nommod.ljust(8)+'.MODELE    .LIEL')
 671
 672     # Creation de la liste des mailles
 673     ll = []
 674     for type_maille in _DIC_MA.keys():
 675       ll.extend( _DIC_MA[type_maille][0:-1] )
 676     _LST_MA = N.array( ll ) - 1
 677
 678     if self.OPTIONS['INFO']>=5:
 679       print '\n# ----- MODELE ----- #\n'
 680       print '_LST_MA=',len(_LST_MA),_LST_MA
 681       print '_DIC_MA=',len(_DIC_MA),_DIC_MA
 682
 683     return _LST_MA
 684
 685
 686 # ---------------------------------------------------------------------------- #
 687
 688   def Creation_Listes_Mailles_Par_Dim(self, _LST_TMA, _LST_MA=None):
 689
 690     t0 = time.clock()
 691
 692     # Si _LST_MA est renseigné on extrait la liste des TMA correspondante aux mailles de _LST_MA
 693     if _LST_MA != None:
 694       _LST_TMA = N.take(_LST_TMA,_LST_MA)
 695     else:
 696       _LST_MA = N.arange(len(_LST_TMA))
 697
 698     _D_DIM_MAILLES = {}
 699
 700     # Liste des mailles 3D (type maille de 18 à 26)
 701     _lst = N.where( _LST_TMA>=18, -3, _LST_TMA )
 702     _tmp = N.where( _lst==-3, -1, 0 )
 703 #    _D_DIM_MAILLES[3] = N.nonzero( _tmp )
 704     _D_DIM_MAILLES[3] = N.take(_LST_MA, N.nonzero( _tmp ) )
 705
 706     # Liste des mailles 2D (type maille de 7 à 17)
 707     _lst = N.where( _lst>=7, -2, _lst )
 708     _tmp = N.where( _lst==-2, -1, 0 )
 709     _D_DIM_MAILLES[2] = N.take(_LST_MA, N.nonzero( _tmp ) )
 710
 711     # Liste des mailles 1D (type maille de 2 à 6)
 712     _lst = N.where( _lst>=2, -1, _lst )
 713     _tmp = N.where( _lst==-1, -1, 0 )
 714     _D_DIM_MAILLES[1] = N.take(_LST_MA, N.nonzero( _tmp ) )
 715
 716     # Liste des mailles 0D (type maille 1)
 717     _lst = N.where( _lst>=1, -4, _lst )
 718     _tmp = N.where( _lst==-4, -1, 0 )
 719     _D_DIM_MAILLES[0] = N.take(_LST_MA, N.nonzero( _tmp ) )
 720
 721
 722     if self.OPTIONS['INFO']>=5:
 723       for i in _D_DIM_MAILLES.keys():
 724         print "-----------------"
 725         print 'Dim:',i, _D_DIM_MAILLES[i]
 726       print "-----------------"
 727
 728     print "--- FIN Creation des listes de mailles par Dim : ", time.clock() - t0
 729
 730     return _D_DIM_MAILLES
 731
 732
 733 # ---------------------------------------------------------------------------- #
 734
 735   def Connectivite_Aretes(self, OPTION=None, _LST_OK=None):
 736
 737     t0 = time.clock()
 738
 739     # Si _LST_OK n'est pas renseigné on prend toutes les mailles
 740     if not _LST_OK: _LST_OK = N.arange(len(self.MAILLAGE_Python.tm))
 741
 742     if self.OPTIONS['INFO']>=5: print '_LST_OK (ca)=',_LST_OK
 743
 744     maille2aretes = self.maille2aretes
 745
 746     # Creation de la :
 747     #   - connectivite des aretes (self.MAILLAGE_Python.ca) : m1 -> [ (a1, a2), .. ]
 748     #   - connectivite inverse des aretes (self.MAILLAGE_Python.cia) : (a1, a2) -> [ m1, m2, ... ]
 749
 750     self.MAILLAGE_Python.ca  = {}
 751     self.MAILLAGE_Python.cia = {}
 752
 753     for n in _LST_OK:
 754
 755         n1 = self.MAILLAGE_Python.tm[n]
 756
 757         l_aretes = maille2aretes[n1]           # liste des aretes de la maille n
 758         l_noeuds = self.MAILLAGE_Python.co[n]  # liste des noeuds de la maille n
 759
 760         for arete in l_aretes:
 761           ll = []
 762           for i in arete:
 763             ll.append( l_noeuds[i] )
 764           ll.sort()
 765           ll = tuple(ll)
 766
 767           # Table de connectivité des aretes
 768           if OPTION:
 769             if not self.MAILLAGE_Python.ca.has_key(n): self.MAILLAGE_Python.ca[n]=[]
 770             self.MAILLAGE_Python.ca[n].append(ll)
 771 #             try:
 772 #               self.MAILLAGE_Python.ca[n].append(ll)
 773 #             except KeyError:
 774 #               self.MAILLAGE_Python.ca[n]=[ll]
 775
 776           # Table de connectivité inverse des aretes
 777           if not self.MAILLAGE_Python.cia.has_key(ll): self.MAILLAGE_Python.cia[ll]=[]
 778           self.MAILLAGE_Python.cia[ll].append(n)
 779 #           try:
 780 #             self.MAILLAGE_Python.cia[ll].append(n)
 781 #           except KeyError:
 782 #             self.MAILLAGE_Python.cia[ll]=[n]
 783
 784
 785     if self.OPTIONS['INFO']>=5:
 786       for k in self.MAILLAGE_Python.cia.keys():
 787         print 'cia:',k, '     ', self.MAILLAGE_Python.cia[k]
 788       if OPTION:
 789         for k in self.MAILLAGE_Python.ca.keys():
 790           print 'ca: ',k, '     ', self.MAILLAGE_Python.ca[k]
 791
 792
 793     print "--- FIN Creation de la connectivite simple et inverse des aretes : ", time.clock() - t0
 794
 795     return
 796
 797
 798 # ---------------------------------------------------------------------------- #
 799
 800   def Elimination_Mailles_de_bords(self, MAILLAGE_Python, _D_DIM_MAILLES, _DIM):
 801     """
 802     Extraction des mailles de bords (mailles incluses dans un bord d une autre maille)
 803     """
 804
 805     t0 = time.clock()
 806
 807     _LST_TMA = self.MAILLAGE_Python.tm
 808
 809     if self.OPTIONS['INFO']>=5:
 810       MAILLAGE = self.ASTER['MAILLAGE']
 811       nommail = string.ljust(MAILLAGE.nom,8)
 812       _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
 813
 814     # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire)
 815     maille2nb = self.maille2nb
 816
 817
 818     # construction des listes des mailles de dim N-1 :
 819     # _LST_OK :   Mailles de dim N-i qui ne sont pas un bord des mailles de dim N
 820     # _LST_BD :   Mailles de dim N-i qui sont un bord
 821     #
 822     if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', _DIM - 1
 823
 824     _LST4 = _D_DIM_MAILLES[ _DIM - 1 ]
 825     _LST_IND = N.arange( len(_LST4) ) + 1  # on ajoute 1 pour eviter le premier 0 dans les test nonzero plus bas
 826
 827     if self.OPTIONS['INFO']>=5: print '  Mailles concernées=',_LST4
 828
 829     i=0
 830     for m in _LST4:
 831       if self.OPTIONS['INFO']>=5: print '\n  Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)'
 832       nb = maille2nb[ self.MAILLAGE_Python.tm[m] ]
 833       ll = self.MAILLAGE_Python.co[m][0:nb]
 834       ll = N.sort(ll)
 835       ll = ll.tolist()
 836       ll = tuple(ll)
 837       if self.OPTIONS['INFO']>=5: print '  Bord (lineaire)', ll, nb
 838
 839       try:
 840         if self.OPTIONS['INFO']>=5: print '  CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)'
 841         _tmp=[]
 842         for maille in self.MAILLAGE_Python.cia[ ll ]:
 843           if self.OPTIONS['INFO']>=5: print '  Maille N:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' TMA:', self.MAILLAGE_Python.tm[maille]
 844 #        self.liste_mailles_bord.append(m)
 845       except:
 846         if self.OPTIONS['INFO']>=5: print '  Maille non-bord'
 847         _LST_IND[i] = 0
 848
 849       i+=1
 850
 851     # Recuperation des mailles de bords et non-bords
 852     _LST_BD = N.nonzero(_LST_IND)
 853     _LST_BD = N.take(_LST4,_LST_BD)
 854
 855     _LST_OK = N.where( _LST_IND==0, 1 , 0 )
 856     _LST_OK = N.nonzero(_LST_OK)
 857     _LST_OK = N.take(_LST4,_LST_OK)
 858
 859     if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', _DIM - 1,' :',_LST_BD
 860     if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', _DIM - 1,'qui ne sont pas des bords :',_LST_OK
 861
 862     print "--- FIN Maille de bords de DIM",_DIM - 1, " : ", time.clock() - t0
 863     t0 = time.clock()
 864
 865
 866     # On cherche à marier les mailles de dimension N-2, N-3
 867     # Peut etre lent car on utilise la connectivité ! Mais pour le moment on a rien d'autre.
 868
 869     _LST_BD0 = []
 870     _LST_OK0 = []
 871     _D_BD = {}
 872     for d in range(_DIM-1):
 873       _LST4 = _D_DIM_MAILLES[ d ]
 874       if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', d
 875       if self.OPTIONS['INFO']>=5: print '  Mailles concernées=',_LST4
 876       for mai in _LST4:
 877         if self.OPTIONS['INFO']>=5: print '\n  Maille:', mai, ' Aster:',string.strip(_LST_MAI[mai]), ' TMA:',self.MAILLAGE_Python.tm[mai], ' CO:',self.MAILLAGE_Python.co[mai], '(noeuds de cette maille)'
 878
 879         nb = maille2nb[ self.MAILLAGE_Python.tm[mai] ]
 880         ll = self.MAILLAGE_Python.co[mai][0:nb]
 881         ll = N.sort(ll)
 882         ll = ll.tolist()
 883         _tmp = tuple(ll)
 884 #        _tmp = self.MAILLAGE_Python.co[mai]
 885
 886         if self.OPTIONS['INFO']>=5: print '  Bord (lineaire):', _tmp, nb
 887
 888         ok=0
 889         for arete in self.MAILLAGE_Python.cia:
 890           _nb=0
 891           for noe in _tmp:
 892             if noe in arete: _nb+=1
 893           if _nb == len(_tmp):
 894             if self.OPTIONS['INFO']>=5: print '  Maille N+i:', self.MAILLAGE_Python.cia[arete], '- Arete:', arete
 895             _LST_BD0.append( mai )
 896             ok=1
 897 #             if not _D_BD.has_key( mai ): _D_BD[mai] = []
 898 #             _D_BD[mai].append( self.MAILLAGE_Python.cia[arete] )
 899             break
 900         if ok == 0:
 901           _LST_OK0.append( mai )
 902
 903 #        print 'Mai:',mai, '_D_BD[mai]=',_D_BD[mai]
 904
 905
 906       if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', d,' :',_LST_BD0
 907       if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', d,'qui ne sont pas des bords :',_LST_OK0
 908
 909
 910       print '--- FIN Maille de bords de DIM', d, ' :',time.clock() - t0
 911       t0 = time.clock()
 912
 913
 914     _LST_OK = N.concatenate( (_LST_OK, N.array(_LST_OK0)) )
 915     _LST_BD = N.concatenate( (_LST_BD, N.array(_LST_BD0)) )
 916
 917     if self.OPTIONS['INFO']>=5: print '\nTotal:\nListe Maille de bords=',_LST_BD
 918     if self.OPTIONS['INFO']>=5: print 'Liste Maille non-bords=',_LST_OK,'\n'
 919
 920 #    print "--- FIN Maille de bords 3 : ", time.clock() - t0
 921
 922     return _LST_OK, _LST_BD
 923
 924
 925 # ---------------------------------------------------------------------------- #
 926
 927   def Affectation_Mailles_de_bords(self, _LST_BD, _DIM):
 928     """
 929     Affectation a un SD des mailles de bords (mailles incluses dans un bord d une autre maille)
 930     """
 931
 932     if self.OPTIONS['INFO']>=5:
 933       print 'liste_mailles_bord=', self.liste_mailles_bord
 934       print 'liste_sd_bord', self.liste_sd_bord
 935       print '_LST_BD=',_LST_BD
 936
 937
 938     MAILLAGE = self.ASTER['MAILLAGE']
 939     _LST_TMA = self.MAILLAGE_Python.tm
 940
 941     if self.OPTIONS['INFO']>=5:
 942       nommail = string.ljust(MAILLAGE.nom,8)
 943       _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
 944
 945     t0 = time.clock()
 946
 947     # Affectation des mailles de bords à chacun des SD
 948
 949     # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire)
 950     maille2nb = self.maille2nb
 951
 952     i = 0
 953     for m in _LST_BD:
 954       if self.OPTIONS['INFO']>=5: print '\n  Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)'
 955       nb = maille2nb[ self.MAILLAGE_Python.tm[m] ]
 956       ll = self.MAILLAGE_Python.co[m][0:nb]
 957       ll = N.sort(ll)
 958       ll = ll.tolist()
 959       ll = tuple(ll)
 960       if self.OPTIONS['INFO']>=5: print '  Bord (lineaire)', ll, nb
 961
 962       # Cas particulier des POI1 en 2D et 3D (ils ne peuvent etre des bords d'elements 2D ou 3D)
 963       if ( (nb==1) and (_DIM>=2) ):
 964         _tmp=[]
 965         for arete in self.MAILLAGE_Python.cia.keys():
 966           if ll[0] in arete:
 967             for maille in self.MAILLAGE_Python.cia[ arete ]:
 968               if self.OPTIONS['INFO']>=5: print '  Maille N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete
 969               _tmp.append( self.liste_sd[maille] )
 970
 971       # Cas particulier des SEG en 3D (ils ne peuvent etre des bords d'elements 3D)
 972       elif ( (nb==2) and (_DIM==3) ):
 973         _tmp=[]
 974         for arete in self.MAILLAGE_Python.cia.keys():
 975           _nb=0
 976           for noe in ll:
 977             if noe in arete: _nb+=1
 978           if _nb == len(ll):
 979             for maille in self.MAILLAGE_Python.cia[arete]:
 980               if self.OPTIONS['INFO']>=5: print '  Mailles N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete
 981               _tmp.append( self.liste_sd[maille] )
 982
 983       # Autres mailles de bord
 984       else:
 985         if self.OPTIONS['INFO']>=5: print '  CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)'
 986         _tmp=[]
 987         for maille in self.MAILLAGE_Python.cia[ ll ]:
 988           if self.OPTIONS['INFO']>=5: print '  Maille N+i:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' SD:', self.liste_sd[maille], ' TMA:', self.MAILLAGE_Python.tm[maille]
 989           _tmp.append( self.liste_sd[maille] )
 990
 991       # integre la maille au SD le plus faible (pour que des groupes de bords se retrouvent dans le meme SD)
 992       _tmp.sort()
 993       self.liste_mailles_bord.append(m)
 994       self.liste_sd_bord.append( _tmp[0] )
 995       i += 1
 996       if self.OPTIONS['INFO']>=5: print '  ---> Maille:',m,'integree au SD:', _tmp[0]
 997
 998     if self.OPTIONS['INFO']>=5:
 999       print '\n\nliste_mailles_bord=', self.liste_mailles_bord
1000       print 'liste_sd_bord=', self.liste_sd_bord
1001
1002
1003     print "--- FIN Affectation des mailles de bords : ", time.clock() - t0
1004
1005     return
1006
1007
1008 # ---------------------------------------------------------------------------- #
1009
1010   def Creation_Graphe(self):
1011
1012     t0 = time.clock()
1013
1014     # Creation du graphe complet
1015     self.GRAPH = {}
1016
1017     for mai in self.liste_mailles:
1018       _ll=[]
1019       for are in self.MAILLAGE_Python.ca[mai]:
1020         _ll.extend( self.MAILLAGE_Python.cia[are] )
1021         _mm = enleve_doublons_liste(_ll)  # coute cher!
1022       _tmp = _mm.tolist()
1023       _tmp.remove(mai)
1024       self.GRAPH[mai] = _tmp
1025
1026       if self.OPTIONS['INFO']>=5: print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai]
1027
1028     print "--- FIN Creation du graphe complet : ", time.clock() - t0
1029
1030     return
1031
1032
1033 # ---------------------------------------------------------------------------- #
1034
1035   def Reduction_Graphe(self, _DIM):
1036
1037     t0 = time.clock()
1038
1039     # Elimination des connectivités à interface nulle
1040     maille2dim = self.maille2dim
1041     _lst2 = []
1042     for mai in self.liste_mailles:
1043       if self.OPTIONS['INFO']>=5: print '\nmai:', mai, 'co:', self.MAILLAGE_Python.co[mai], 'tm:', self.MAILLAGE_Python.tm[mai]
1044       _DIM1 = maille2dim[ self.MAILLAGE_Python.tm[mai] ]
1045       _tmp2 =[]
1046       for mai2 in self.GRAPH[mai]:
1047         if self.OPTIONS['INFO']>=5: print 'mai2:', mai2, 'co:', self.MAILLAGE_Python.co[mai2], 'tm:', self.MAILLAGE_Python.tm[mai2]
1048         # calcule le nombre de noeuds communs aux deux mailles
1049         _nb = 0
1050         for noe in self.MAILLAGE_Python.co[mai2]:
1051           if noe in self.MAILLAGE_Python.co[mai]: _nb += 1
1052         _DIM2 = maille2dim[ self.MAILLAGE_Python.tm[mai2] ]
1053         if _nb >= min(_DIM1, _DIM2):  # le min permet de faire du collage 3D-coque par exemple
1054           _tmp2.append( mai2 )
1055           _tmp = [mai, mai2]
1056           _tmp.sort()
1057           _lst2.append(_tmp)
1058       self.GRAPH[mai] = _tmp2
1059
1060     print "--- FIN Elimination des connectivités avec une interface nulle : ", time.clock() - t0
1061     t0 = time.clock()
1062
1063
1064     # Calcul du nombre d'aretes
1065     # A voir : normalement il n'y a rien a faire car nb0 = 2*nb (a verifier...)
1066     _lst2.sort()
1067     _v = _lst2[0]
1068     _nb = 1
1069     for i in _lst2:
1070       if i != _v:
1071         _v = i
1072         _nb += 1
1073
1074
1075     if self.OPTIONS['INFO']>=5:
1076       print '----------------------------------------------'
1077       for mai in self.liste_mailles:
1078         print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai]
1079       print '----------------------------------------------'
1080
1081     return _nb
1082
1083
1084 # ------------------------------------------------------------------ #
1085
1086   def Ecrire_Graphe(self, f_metis, _nb):
1087
1088     t0 = time.clock()
1089
1090     # On doit renumeroter les mailles qui arrivent dans self.liste_mailles pour avoir 0... N-1
1091     _D_CORRES = {}
1092     for i in N.arange(len(self.liste_mailles)):
1093       _D_CORRES[ self.liste_mailles[i] ] = i
1094
1095     # Ecriture du fichier fort.UL pour metis
1096     fw = open(f_metis,'w')
1097     fw.write( str(len(self.liste_mailles)) + ' ' +  str(_nb) + '\n')
1098     for l in self.liste_mailles:
1099 #      try:
1100         _tmp = []
1101         for t in self.GRAPH[l]:
1102           try:
1103             t = _D_CORRES[t]
1104             _tmp.append( str(t+1) )    # Necessaire car metis numerote de 1 à N
1105           except:
1106             print 'on oublie le bord:', t
1107         fw.write( string.join(_tmp, ' ') + '\n' )
1108 #      except:
1109 #        print 'Probleme ecriture graphe! On continue..'
1110     fw.close()
1111
1112     print "--- FIN Ecriture du fichier du graphe pour metis : ", time.clock() - t0
1113
1114     return _D_CORRES
1115
1116
1117 # ---------------------------------------------------------------------------- #
1118
1119   def Lecture_fichier_sdd(self, fichier, _LST_OK):
1120
1121     t0 = time.clock()
1122
1123     # Lecture du fichier produit par metis (partie a optimiser)
1124     try:
1125       f = open( fichier, 'r' )
1126     except:
1127       print "\n\n          ERREUR: le fichier est introuvable! Le partitionneur \n          ne s'est probablement pas lancé.\n\n"
1128       sys.exit(1)
1129     else:
1130       _tmp = []
1131       for l in f.readlines():
1132         _tmp.append( int(string.strip(l)) )
1133       f.close()
1134       _l_domaines = N.array(_tmp,copy=0)
1135
1136       # Pour garder le fichier metis
1137       os.system( 'mv ' + fichier + ' REPE_OUT/' )
1138
1139       if self.OPTIONS['INFO']>=5: print '_l_domaines=',_l_domaines
1140
1141       print "--- FIN Lecture du fichier produit par metis : ", time.clock() - t0
1142
1143     return _l_domaines
1144
1145
1146 # ---------------------------------------------------------------------------- #
1147
1148   def Creation_Group_ma_Python_par_SD(self, NOM='SD', NOM2='B'):
1149
1150     t0 = time.clock()
1151
1152     NB_PART = self.OPTIONS['NB_PART']
1153
1154     # Creation du dictionnaire des listes des mailles par SD
1155     #     d_gma : { num sd -> [ liste mailles ] }
1156     d_gma = {}
1157     for i in range(NB_PART):
1158       d_gma[i] = []
1159
1160     i=0
1161     for sdd in self.liste_sd:
1162       d_gma[sdd].append( self.liste_mailles[i] )
1163       i+=1
1164
1165
1166     # Creation du dictionnaire des listes des mailles de bord par SD
1167     #     d_gma_bord : { num sd -> [ liste mailles ] }
1168     d_gma_bord = {}
1169     for i in range(NB_PART):
1170       d_gma_bord[i] = []
1171
1172     i=0
1173     for sdd in self.liste_sd_bord:
1174       d_gma_bord[sdd].append( self.liste_mailles_bord[i] )
1175       i+=1
1176
1177
1178     # Generation des listes de noms de groupes
1179     _l_sd = []
1180     _l_bord = []
1181     for i in range(NB_PART):
1182       if d_gma[i] != []:
1183         _l_sd.append( NOM + str(i) )
1184       if d_gma_bord[i] != []:
1185         _l_bord.append( NOM2 + str(i) )
1186
1187     # Stockage
1188     self.ASTER['GROUP_MA']        = _l_sd
1189     self.ASTER['GROUP_MA_BORD']   = _l_bord
1190
1191
1192     # Creation des groupes de mailles dans le Maillage Python
1193     for i in range(NB_PART):
1194       self.MAILLAGE_Python.gma[NOM+str(i)]  = d_gma[i]
1195       self.MAILLAGE_Python.gma[NOM2+str(i)] = d_gma_bord[i]
1196
1197     print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0
1198
1199     return
1200
1201
1202 # ---------------------------------------------------------------------------- #
1203
1204   def Creation_Group_ma_Aster_par_SD(self, NOM='SD', NOM2='B', INCLUSE='NON'):
1205
1206     t0 = time.clock()
1207
1208     MAILLAGE    = self.ASTER['MAILLAGE']
1209     NB_PART     = self.OPTIONS['NB_PART']
1210
1211     nommail     = string.ljust(MAILLAGE.nom,8)
1212     _LST_MAI    = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
1213
1214
1215     # Creation du dictionnaire des listes des mailles par SD
1216     #     d_gma : { num sd -> [ liste mailles ] }
1217     d_gma = {}
1218     for i in range(NB_PART):
1219       d_gma[i] = []
1220
1221     m=0
1222     for sdd in self.liste_sd:
1223       d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles[m] ]) )   # voir si le strip coute cher !
1224       m += 1
1225
1226
1227     # Creation du dictionnaire des listes des mailles de bord par SD
1228     #     d_gma_bord : { num sd -> [ liste mailles ] }
1229     d_gma_bord = {}
1230     for i in range(NB_PART):
1231       d_gma_bord[i] = []
1232
1233     # On inclus directement les mailles de bords dans les SD
1234     if INCLUSE=='OUI':
1235       m=0
1236       for sdd in self.liste_sd_bord:
1237         d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) )   # voir si le strip coute cher !
1238         m+=1
1239
1240     else:
1241       m=0
1242       for sdd in self.liste_sd_bord:
1243         d_gma_bord[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) )   # voir si le strip coute cher !
1244         m+=1
1245
1246
1247     print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0
1248     t0 = time.clock()
1249
1250
1251     # Creation et lancement de la commande DEFI_GROUP associée
1252     try:
1253       DEFI_GROUP = self.jdc.get_cmd('DEFI_GROUP')
1254     except:
1255       try:
1256         from Cata.cata import DEFI_GROUP
1257       except:
1258         print "\n\nERREUR : il faut lancer ce programme depuis Aster pour pouvoir \ngénérer les groupes de mailles Aster.\n\n"
1259         return
1260
1261     _tmp  = []
1262     _l_sd = []
1263     _l_bord = []
1264     for i in range(NB_PART):
1265       if d_gma[i] != []:
1266         _tmp.append( {'MAILLE': d_gma[i],'NOM': NOM + str(i)} )
1267         _l_sd.append( NOM + str(i) )
1268       if d_gma_bord[i] != []:
1269         _tmp.append( {'MAILLE': d_gma_bord[i],'NOM': NOM2 + str(i)} )
1270         _l_bord.append( NOM2 + str(i) )
1271
1272     motscle2= {'CREA_GROUP_MA': _tmp }
1273
1274     DEFI_GROUP( reuse=MAILLAGE,
1275                 MAILLAGE=MAILLAGE,
1276                 INFO=1,
1277                 **motscle2
1278                ) ;
1279
1280     # Stockage
1281     self.ASTER['DICO_SD_MAILLES'] = d_gma
1282     self.ASTER['GROUP_MA']        = _l_sd
1283     self.ASTER['GROUP_MA_BORD']   = _l_bord
1284
1285     print "--- FIN Creation et lancement de la commande DEFI_GROUP associée : ", time.clock() - t0
1286
1287     return
1288
1289 # ---------------------------------------------------------------------------- #