Aster/Cata/cataSTA9/Macro/lire_fonction_ops.py

   1 #@ MODIF lire_fonction_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE
   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
  21 import os.path, Numeric
  22
  23 class LectureBlocError(Exception):
  24    pass
  25
  26 # ------------------------------------------------------------------------------
  27 def lire_blocs(nomfich, SEPAR):
  28    """Retourne la liste des blocs
  29    """
  30    def info(ib, nlig, ncol):
  31       """Affiche les infos d'un bloc"""
  32       print "   . Bloc %2d : %6d lignes, %6d colonnes" % (ib, nlig, ncol)
  33    print "  Lecture des blocs du fichier '%s'" % nomfich
  34    fich=open(nomfich, 'r')
  35    if SEPAR == 'None':
  36       SEPAR=None
  37    blocs  = []
  38    lignes = []
  39    llen=0
  40    il=0
  41    for line in fich:
  42       il+=1
  43       try:
  44          if line.strip()=='':
  45             raise ValueError
  46          splin = line.split(SEPAR)
  47          lignes.append(map(float, splin))
  48          if llen==0:
  49             llen=len(splin)
  50          elif len(splin) != llen:
  51             raise LectureBlocError,  'Ligne %d : %d champs au lieu de %d attendus' % (il, len(splin), llen)
  52       except ValueError:
  53          if lignes==[]:
  54             pass  # dans ce cas, on a plusieurs lignes délimitant 2 fonctions
  55          else:
  56             blocs.append(Numeric.array(lignes))
  57             info(len(blocs), len(lignes), llen)
  58             lignes=[]
  59             llen=0
  60    fich.close()
  61    if len(lignes) > 0 :
  62       blocs.append(Numeric.array(lignes))
  63       info(len(blocs), len(lignes), llen)
  64    return blocs
  65
  66 # ------------------------------------------------------------------------------
  67 def liste_double(nomfich,INDIC_PARA,INDIC_RESU,SEPAR):
  68   """Méthode de construction du VALE pour le format libre
  69   format LIBRE
  70   Les lignes contenant autre chose que des séquences de nombres
  71   réels et de séparateurs sont considérées comme délimitant deux
  72   fonctions différentes. Cette situation correspond à l exception
  73   ValueError levée par le map de float. Le deuxieme indice de
  74   INDIC_PARA et INDIC_RESU est l indice permettant de pointer sur la
  75   fonction voulue, au sens de ce découpage.
  76   """
  77   from Utilitai.transpose import transpose
  78   blocs = lire_blocs(nomfich, SEPAR)
  79
  80   # vérifications de cohérences lignes et colonnes
  81   nb_blocs = len(blocs)
  82   bloc_para = INDIC_PARA[0]
  83   col_para  = INDIC_PARA[1]
  84   bloc_resu = INDIC_RESU[0]
  85   col_resu  = INDIC_RESU[1]
  86   if bloc_para > nb_blocs :
  87      raise LectureBlocError, "Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)
  88   if bloc_resu > nb_blocs:
  89      raise LectureBlocError, "Il y a %d blocs or INDIC_RESU=(%d, .)" % (nb_blocs, bloc_resu)
  90
  91   if col_para > len(blocs[bloc_para-1][0]):
  92      raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \
  93          (bloc_para, len(blocs[bloc_para-1][0]), col_para)
  94   if col_resu > len(blocs[bloc_resu-1][0]):
  95      raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_RESU=(., %d)" % \
  96          (bloc_resu, len(blocs[bloc_resu-1][0]), col_resu)
  97
  98   # construction du VALE de la fonction par recherche des indices
  99   # de colonnes et de fonctions dans le tableau blocs
 100   vale_para = blocs[bloc_para-1][:,col_para-1]
 101   vale_resu = blocs[bloc_resu-1][:,col_resu-1]
 102   if len(vale_para) != len(vale_resu) :
 103      print 'VALE_PARA =', vale_para
 104      print 'VALE_RESU =', vale_resu
 105      message="""Les deux colonnes extraites n'ont pas la meme longueur
 106          %d lignes pour PARA
 107          %d lignes pour RESU""" % (len(vale_para), len(vale_resu))
 108      raise LectureBlocError, message
 109
 110   laux=transpose([vale_para, vale_resu])
 111   liste_vale=[]
 112   for v in laux:
 113      liste_vale.extend(v)
 114   return liste_vale
 115
 116 # ------------------------------------------------------------------------------
 117 def liste_simple(nomfich,INDIC_PARA,SEPAR):
 118   """recherche d'une liste simple
 119   """
 120   blocs = lire_blocs(nomfich, SEPAR)
 121
 122   # vérifications de cohérences lignes et colonnes
 123   nb_blocs = len(blocs)
 124   bloc_para = INDIC_PARA[0]
 125   col_para  = INDIC_PARA[1]
 126   if bloc_para > nb_blocs :
 127      raise LectureBlocError, "Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)
 128   if col_para > len(blocs[bloc_para-1][0]):
 129      raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \
 130          (bloc_para, len(blocs[bloc_para-1][0]), col_para)
 131
 132   # construction du VALE de la fonction par recherche des indices
 133   # de colonnes et de fonctions dans le tableau l_fonc
 134   vale_1=blocs[bloc_para-1][:,col_para-1]
 135   return vale_1.tolist()
 136
 137 # ------------------------------------------------------------------------------
 138 def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE,
 139                       NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
 140                       PROL_GAUCHE,VERIF,INFO,TITRE,**args):
 141   """Méthode corps de la macro
 142   """
 143   from Accas import _F
 144   from Utilitai.Utmess     import  UTMESS
 145   from Utilitai.UniteAster import UniteAster
 146
 147   ier=0
 148   # La macro compte pour 1 dans la numerotation des commandes
 149   self.set_icmd(1)
 150
 151   # On recopie le mot cle defi_fonction pour le proteger
 152   if TYPE=='NAPPE' :
 153      mc_DEFI_FONCTION=args['DEFI_FONCTION']
 154
 155   # On importe les definitions des commandes a utiliser dans la macro
 156   DEFI_FONCTION  =self.get_cmd('DEFI_FONCTION')
 157   DEFI_NAPPE     =self.get_cmd('DEFI_NAPPE')
 158
 159   nompro='LIRE_FONCTION'
 160
 161   # Lecture de la fonction dans un fichier d unité logique UNITE
 162   UL = UniteAster()
 163   nomfich=UL.Nom(UNITE)
 164   if not os.path.isfile(nomfich):
 165      UTMESS('F','FONCT0_41',valk=nomfich)
 166
 167   # fonction(_c) ou nappe en sortie
 168   self.DeclareOut('ut_fonc',self.sd)
 169
 170   if   TYPE=='FONCTION':
 171     # mise en forme de la liste de valeurs suivant le format choisi :
 172     try:
 173        liste_vale = liste_double(nomfich,INDIC_PARA,args['INDIC_RESU'],SEPAR)
 174     except LectureBlocError, message:
 175        UTMESS('F', 'FONCT0_42', valk=message)
 176
 177     # création de la fonction ASTER :
 178     ut_fonc=DEFI_FONCTION( NOM_PARA   =NOM_PARA,
 179                            NOM_RESU   =NOM_RESU,
 180                            PROL_DROITE=PROL_DROITE,
 181                            PROL_GAUCHE=PROL_GAUCHE,
 182                            INTERPOL   =INTERPOL,
 183                            INFO       =INFO,
 184                            TITRE      =TITRE,
 185                            VERIF      =VERIF,
 186                            VALE       =liste_vale,)
 187
 188   elif TYPE=='FONCTION_C':
 189     # mise en forme de la liste de valeurs suivant le format choisi :
 190     if 'INDIC_REEL' in args :
 191                               indic1=args['INDIC_REEL']
 192                               indic2=args['INDIC_IMAG']
 193     if 'INDIC_MODU' in args :
 194                               indic1=args['INDIC_MODU']
 195                               indic2=args['INDIC_PHAS']
 196     try:
 197        liste_vale_r = liste_double(nomfich,INDIC_PARA,indic1,SEPAR)
 198     except LectureBlocError, message:
 199        UTMESS('F', 'FONCT0_42', valk=message)
 200
 201     try:
 202        liste_vale_i = liste_double(nomfich,INDIC_PARA,indic2,SEPAR)
 203     except LectureBlocError, message:
 204        UTMESS('F', 'FONCT0_42', valk=message)
 205
 206     liste=[]
 207     if   'INDIC_REEL' in args :
 208       for i in range(len(liste_vale_r)/2) :
 209         liste.extend([liste_vale_r[2*i],liste_vale_r[2*i+1],liste_vale_i[2*i+1]])
 210     elif 'INDIC_MODU' in args :
 211       for i in range(len(liste_vale_r)/2) :
 212         module=liste_vale_r[2*i+1]
 213         phase =liste_vale_i[2*i+1]
 214         liste.extend([liste_vale_r[2*i],module*cos(phase),module*sin(phase)])
 215
 216     # création de la fonction ASTER :
 217     ut_fonc=DEFI_FONCTION( NOM_PARA    =NOM_PARA,
 218                            NOM_RESU    =NOM_RESU,
 219                            PROL_DROITE =PROL_DROITE,
 220                            PROL_GAUCHE =PROL_GAUCHE,
 221                            INTERPOL    =INTERPOL,
 222                            INFO        =INFO,
 223                            TITRE       =TITRE,
 224                            VERIF       =VERIF,
 225                            VALE_C      =liste,)
 226
 227   elif TYPE=='NAPPE':
 228
 229     # création de la nappe ASTER :
 230     motscles={}
 231     motscles['DEFI_FONCTION']=[]
 232     for elem in mc_DEFI_FONCTION:
 233        try:
 234           liste_vale=liste_double(nomfich,args['INDIC_ABSCISSE'],elem['INDIC_RESU'],SEPAR)
 235        except LectureBlocError, message:
 236           UTMESS('F', 'FONCT0_42', valk=message)
 237
 238        motscles['DEFI_FONCTION'].append( _F( VALE       =liste_vale,
 239                                              INTERPOL   =args['INTERPOL_FONC'],
 240                                              PROL_DROITE=args['PROL_DROITE_FONC'],
 241                                              PROL_GAUCHE=args['PROL_GAUCHE_FONC'] ) )
 242     try:
 243        liste_para = liste_simple(nomfich,INDIC_PARA,SEPAR)
 244     except LectureBlocError, message:
 245        UTMESS('F', 'FONCT0_42', valk=message)
 246
 247     # création de la nappe
 248     ut_fonc=DEFI_NAPPE( PARA          =liste_para,
 249                         NOM_PARA      =NOM_PARA,
 250                         NOM_PARA_FONC =args['NOM_PARA_FONC'],
 251                         NOM_RESU      =NOM_RESU,
 252                         PROL_DROITE   =PROL_DROITE,
 253                         PROL_GAUCHE   =PROL_GAUCHE,
 254                         INTERPOL      =INTERPOL,
 255                         INFO          =INFO,
 256                         TITRE         =TITRE,
 257                         VERIF         =VERIF,
 258                         **motscles)
 259   # remet UNITE dans son état initial
 260   UL.EtatInit()
 261   return ier