Aster/Cata/cataSTA74/Macro/lire_fonction_ops.py

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