Aster/Cata/cataSTA73/Macro/lire_fonction_ops.py

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