Aster/Cata/ops.py

   1 #@ MODIF ops Cata  DATE 20/01/2003   AUTEUR DURAND C.DURAND
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 # ======================================================================
  19
  20 # Modules Python
  21 import types
  22 import string,linecache,os,traceback,re
  23
  24 # Modules Eficas
  25 import Accas
  26 from Accas import ASSD
  27 from Noyau.N_FONCTION import fonction
  28
  29 try:
  30    import aster
  31    # Si le module aster est présent, on le connecte
  32    # au JDC
  33    import Build.B_CODE
  34    Build.B_CODE.CODE.codex=aster
  35 except:
  36    pass
  37
  38 def DEBUT(self,PAR_LOT,CODE,**args):
  39    """
  40        Fonction sdprod de la macro DEBUT
  41    """
  42    self.jdc.set_par_lot(PAR_LOT)
  43    if CODE!=None :
  44       self.jdc.fico=CODE.valeur['NOM']
  45    else:
  46       self.jdc.fico=None
  47
  48 def build_debut(self,**args):
  49    """
  50    Fonction ops pour la macro DEBUT
  51    """
  52    if self.jdc.par_lot == 'NON' :
  53       self.jdc._Build()
  54    # On execute la fonction debut pour initialiser les bases
  55    # Cette execution est indispensable avant toute autre action sur ASTER
  56    # op doit etre un entier car la fonction debut appelle GCECDU qui demande
  57    # le numero de l'operateur associé (getoper)
  58    self.definition.op=0
  59    self.set_icmd(1)
  60    lot,ier=self.codex.debut(self,1)
  61    # On remet op a None juste apres pour eviter que la commande DEBUT
  62    # ne soit executée dans la phase d'execution
  63    self.definition.op=None
  64    return ier
  65
  66 def POURSUITE(self,PAR_LOT,CODE,**args):
  67    """
  68        Fonction sdprod de la macro POURSUITE
  69    """
  70    self.jdc.set_par_lot(PAR_LOT)
  71    if CODE!=None :
  72       self.jdc.fico=CODE.valeur['NOM']
  73    else:
  74       self.jdc.fico=None
  75    if self.codex and os.path.isfile("glob.1"):
  76      # Le module d'execution est accessible et glob.1 est present
  77      # Pour eviter de rappeler plusieurs fois la sequence d'initialisation
  78      # on memorise avec l'attribut fichier_init que l'initialisation
  79      # est réalisée
  80      if hasattr(self,'fichier_init'):return
  81      self.fichier_init='glob.1'
  82      self.jdc.initexec()
  83      # le sous programme fortran appelé par self.codex.poursu demande le numero
  84      # de l'operateur (GCECDU->getoper), on lui donne la valeur 0
  85      self.definition.op=0
  86      lot,ier,lonuti,concepts=self.codex.poursu(self,1)
  87      # Par la suite pour ne pas executer la commande pendant la phase
  88      # d'execution on le remet à None
  89      self.definition.op=None
  90      # On demande la numerotation de la commande POURSUITE avec l'incrément
  91      # lonuti pour qu'elle soit numérotée à la suite des commandes existantes.
  92      self.set_icmd(lonuti)
  93      pos=0
  94      d={}
  95      while pos+80 < len(concepts)+1:
  96        nomres=concepts[pos:pos+8]
  97        concep=concepts[pos+8:pos+24]
  98        nomcmd=concepts[pos+24:pos+40]
  99        statut=concepts[pos+40:pos+48]
 100        print nomres,concep,nomcmd,statut
 101        if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
 102           exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
 103        pos=pos+80
 104      for k,v in d.items():
 105        self.parent.NommerSdprod(v,k)
 106      self.g_context=d
 107      return
 108    else:
 109      # Si le module d'execution n est pas accessible ou glob.1 absent on
 110      # demande un fichier (EFICAS)
 111      # Il faut éviter de réinterpréter le fichier à chaque appel de
 112      # POURSUITE
 113      if hasattr(self,'fichier_init'):
 114         return
 115      self.make_poursuite()
 116
 117 def POURSUITE_context(self,d):
 118    """
 119        Fonction op_init de la macro POURSUITE
 120    """
 121    # self représente la macro POURSUITE ...
 122    d.update(self.g_context)
 123    # Une commande POURSUITE n'est possible qu'au niveau le plus haut
 124    # On ajoute directement les concepts dans le contexte du jdc
 125    # XXX est ce que les concepts ne sont pas ajoutés plusieurs fois ??
 126    for v in self.g_context.values():
 127       if isinstance(v,ASSD) : self.jdc.sds.append(v)
 128
 129 def build_poursuite(self,**args):
 130    """
 131    Fonction ops pour la macro POURSUITE
 132    """
 133    # Pour POURSUITE on ne modifie pas la valeur initialisee dans ops.POURSUITE
 134    # Il n y a pas besoin d executer self.codex.poursu (c'est deja fait dans
 135    # la fonction sdprod de la commande (ops.POURSUITE))
 136    return 0
 137
 138 def INCLUDE(self,UNITE,**args):
 139    """
 140        Fonction sd_prod pour la macro INCLUDE
 141    """
 142    if not UNITE : return
 143    if hasattr(self,'unite'):return
 144    self.unite=UNITE
 145
 146    if self.jdc and self.jdc.par_lot == 'NON':
 147       # On est en mode commande par commande, on appelle la methode speciale
 148       self.Execute_alone()
 149
 150    self.make_include(unite=UNITE)
 151
 152 def INCLUDE_context(self,d):
 153    """
 154        Fonction op_init pour macro INCLUDE
 155    """
 156    for k,v in self.g_context.items():
 157       d[k]=v
 158
 159 def build_include(self,**args):
 160    """
 161    Fonction ops de la macro INCLUDE appelée lors de la phase de Build
 162    """
 163    # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
 164    # le numero de la commande n est pas utile en phase de construction
 165    # La macro INCLUDE ne sera pas numérotée (incrément=None)
 166    self.set_icmd(None)
 167    icmd=0
 168    ier=self.codex.opsexe(self,icmd,-1,1)
 169    return ier
 170
 171 def detruire(self,d):
 172    """
 173        Cette fonction est la fonction op_init de la PROC DETRUIRE
 174    """
 175    sd=[]
 176    for mc in self["CONCEPT"]:
 177      mcs=mc["NOM"]
 178      if type(mcs) == types.ListType or type(mcs) == types.TupleType:
 179        for e in mcs:
 180          if isinstance(e,ASSD):
 181            sd.append(e)
 182            e=e.nom
 183          if d.has_key(e):del d[e]
 184          if self.jdc.sds_dict.has_key(e):del self.jdc.sds_dict[e]
 185      else:
 186        if isinstance(mcs,fonction):
 187          cr=self.parent.report()
 188          cr.fatal("la destruction d'une FORMULE est impossible" )
 189        if isinstance(mcs,ASSD):
 190          sd.append(mcs)
 191          mcs=mcs.nom
 192        if d.has_key(mcs):del d[mcs]
 193        if self.jdc.sds_dict.has_key(mcs):del self.jdc.sds_dict[mcs]
 194    for s in sd:
 195      # On signale au parent que le concept s n'existe plus apres l'étape self
 196      self.parent.delete_concept_after_etape(self,s)
 197
 198 def subst_materiau(text,NOM_MATER,EXTRACTION):
 199    """
 200        Cette fonction retourne un texte obtenu à partir du texte passé en argument (text)
 201        en substituant le nom du materiau par NOM_MATER
 202        et en réalisant les extractions spéciifées dans EXTRACTION
 203    """
 204    lines=string.split(text,'\n')
 205    if EXTRACTION:
 206      ll=[]
 207      regmcf=re.compile(r" *(.*) *= *_F\( *## +(.*) +(.*)")
 208      regmcs=re.compile(r" *(.*) *= *([^ ,]*) *, *## +([^ ]*) *([^ ]*)")
 209      regfin=re.compile(r" *\) *")
 210      temps={};lmcf=[]
 211      for e in EXTRACTION:
 212        mcf=e['COMPOR']
 213        lmcf.append(mcf)
 214        temps[mcf]=e['TEMP_EVAL']
 215      FLAG=0
 216      for l in lines:
 217        m=regmcf.match(l)
 218        if m: # On a trouve un mot cle facteur "commentarise"
 219          if m.group(2) == "SUBST": # il est de plus substituable
 220            if temps.has_key(m.group(3)): # Il est a substituer
 221              ll.append(" "+m.group(3)+"=_F(")
 222              mcf=m.group(3)
 223              TEMP=temps[mcf]
 224              FLAG=1 # Indique que l'on est en cours de substitution
 225            else: # Il n est pas a substituer car il n est pas dans la liste demandee
 226              ll.append(l)
 227          else: # Mot cle facteur commentarise non substituable
 228            ll.append(l)
 229        else:  # La ligne ne contient pas un mot cle facteur commentarise
 230          if FLAG == 0: # On n est pas en cours de substitution
 231            ll.append(l)
 232          else: # On est en cours de substitution. On cherche les mots cles simples commentarises
 233            m=regmcs.match(l)
 234            if m: # On a trouve un mot cle simple commentarise
 235              if m.group(3) == "EVAL":
 236                ll.append("  "+m.group(1)+' = EVAL("'+m.group(4)+"("+str(TEMP)+')"),')
 237              elif m.group(3) == "SUPPR":
 238                pass
 239              else:
 240                ll.append(l)
 241            else: # On cherche la fin du mot cle facteur en cours de substitution
 242              m=regfin.match(l)
 243              if m: # On l a trouve. On le supprime de la liste
 244                FLAG=0
 245                del temps[mcf]
 246              ll.append(l)
 247    else:
 248      ll=lines
 249
 250    for l in ll:
 251      print l
 252    lines=ll
 253    ll=[]
 254    for l in lines:
 255      l=re.sub(" *MAT *= *",NOM_MATER+" = ",l,1)
 256      ll.append(l)
 257    text=string.join(ll,'\n')
 258    return text
 259
 260 def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER,
 261                     EXTRACTION,INFO,**args):
 262   """
 263       Fonction sd_prod pour la macro INCLUDE_MATERIAU
 264   """
 265   mat=string.join((NOM_AFNOR,'_',TYPE_MODELE,'_',VARIANTE,'.',TYPE_VALE),'')
 266   if not hasattr(self,'mat') or self.mat != mat or self.nom_mater != NOM_MATER :
 267     # On récupère le répertoire des matériaux dans les arguments
 268     # supplémentaires du JDC
 269     rep_mat=self.jdc.args.get("rep_mat","NOrep_mat")
 270     f=os.path.join(rep_mat,mat)
 271     self.mat=mat
 272     self.nom_mater=NOM_MATER
 273     if not os.path.isfile(f):
 274        del self.mat
 275        self.make_contexte(f,"#Texte sans effet pour reinitialiser le contexte a vide\n")
 276        raise "Erreur sur le fichier materiau: "+f
 277     # Les materiaux sont uniquement disponibles en syntaxe Python
 278     # On lit le fichier et on supprime les éventuels \r
 279     text=string.replace(open(f).read(),'\r\n','\n')
 280     # On effectue les substitutions necessaires
 281     self.prefix=NOM_MATER
 282     self.text= subst_materiau(text,NOM_MATER,EXTRACTION)
 283     if INFO == 2:
 284       print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
 285       print self.text
 286     # on execute le texte fourni dans le contexte forme par
 287     # le contexte de l etape pere (global au sens Python)
 288     # et le contexte de l etape (local au sens Python)
 289     # Il faut auparavant l'enregistrer aupres du module linecache (utile pour nommage.py)
 290     linecache.cache[f]=0,0,string.split(self.text,'\n'),f
 291     if self.jdc.par_lot == 'NON':
 292       # On est en mode commande par commande, on appelle la methode speciale
 293       self.Execute_alone()
 294
 295     self.make_contexte(f,self.text)
 296
 297 def build_formule(self,**args):
 298   """
 299   Fonction ops de la macro FORMULE appelée lors de la phase de Build
 300   """
 301   from Build import B_utils
 302   for mc in self.mc_liste:
 303     if mc.nom in ('REEL','ENTIER','COMPLEXE'):
 304       texte= self.sd.get_name()+ string.strip(mc.valeur)
 305       mc.valeur=B_utils.ReorganisationDe(texte,80)
 306   # ATTENTION : FORMULE est une des rares commandes qui a besoin de
 307   # connaitre son numero d execution avant d etre construite
 308   self.set_icmd(1)
 309   # La macro formule doit etre executee. Seules les macros qui ont
 310   # un numero d'op sont executees lors des phases suivantes
 311   self.definition.op = -5
 312   ier=self.codex.opsexe(self,self.icmd,-1,-self.definition.op)
 313   return ier
 314
 315 def build_procedure(self,**args):
 316     """
 317     Fonction ops de la macro PROCEDURE appelée lors de la phase de Build
 318     """
 319     ier=0
 320     # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
 321     # le numero de la commande n est pas utile en phase de construction
 322     # On ne numérote pas une macro PROCEDURE (incrément=None)
 323     self.set_icmd(None)
 324     icmd=0
 325     ier=self.codex.opsexe(self,icmd,-1,3)
 326     return ier
 327