Aster/Cata/ops.py

   1 #@ MODIF ops Cata  DATE 09/10/2002   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
  28 try:
  29    import aster
  30    # Si le module aster est présent, on le connecte
  31    # au JDC
  32    import Build.B_CODE
  33    Build.B_CODE.CODE.codex=aster
  34 except:
  35    pass
  36
  37 def DEBUT(self,PAR_LOT,**args):
  38    """
  39        Fonction sdprod de la macro DEBUT
  40    """
  41    self.jdc.set_par_lot(PAR_LOT)
  42
  43 def POURSUITE(self,PAR_LOT,**args):
  44    """
  45        Fonction sdprod de la macro POURSUITE
  46    """
  47    self.jdc.set_par_lot(PAR_LOT)
  48    if self.codex and os.path.isfile("glob.1"):
  49      # Le module d'execution est accessible et glob.1 est present
  50      if hasattr(self,'fichier_init'):return
  51      self.fichier_init='glob.1'
  52      self.jdc.initexec()
  53      lot,ier,lonuti,concepts=self.codex.poursu(self,1)
  54      self.icmd=lonuti
  55      #print "Fin de debut",ier,lot,lonuti
  56      pos=0
  57      d={}
  58      while pos+80 < len(concepts)+1:
  59        nomres=concepts[pos:pos+8]
  60        concep=concepts[pos+8:pos+24]
  61        nomcmd=concepts[pos+24:pos+40]
  62        statut=concepts[pos+40:pos+48]
  63        if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
  64           exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
  65        pos=pos+80
  66      for k,v in d.items():
  67        self.parent.NommerSdprod(v,k)
  68      self.g_context=d
  69      return
  70    else:
  71      # Si le module d'execution n est pas accessible ou glob.1 absent on
  72      # demande un fichier (EFICAS)
  73      # Il faut éviter de réinterpréter le fichier à chaque appel de
  74      # POURSUITE
  75      if hasattr(self,'fichier_init'):
  76         return
  77      self.make_poursuite()
  78
  79 def POURSUITE_context(self,d):
  80    """
  81        Fonction op_init de la macro POURSUITE
  82    """
  83    # self représente la macro POURSUITE ...
  84    d.update(self.g_context)
  85    # Une commande POURSUITE n'est possible qu'au niveau le plus haut
  86    # On ajoute directement les concepts dans le contexte du jdc
  87    # XXX est ce que les concepts ne sont pas ajoutés plusieurs fois ??
  88    for v in self.g_context.values():
  89       if isinstance(v,ASSD) : self.jdc.sds.append(v)
  90
  91 def INCLUDE(self,UNITE,**args):
  92    """
  93        Fonction sd_prod pour la macro INCLUDE
  94    """
  95    if hasattr(self,'unite'):return
  96    self.unite=UNITE
  97
  98    if self.jdc and self.jdc.par_lot == 'NON':
  99       # On est en mode commande par commande
 100       # On teste la validite de la commande avec interruption eventuelle
 101       cr=self.report()
 102       self.parent.cr.add(cr)
 103       if not cr.estvide():
 104          raise EOFError
 105
 106    self.make_include(unite=UNITE)
 107
 108 def INCLUDE_context(self,d):
 109    """
 110        Fonction op_init pour macro INCLUDE
 111    """
 112    for k,v in self.g_context.items():
 113       d[k]=v
 114
 115 def detruire(self,d):
 116    """
 117        Cette fonction est la fonction op_init de la PROC DETRUIRE
 118    """
 119    sd=[]
 120    for mc in self["CONCEPT"]:
 121      mcs=mc["NOM"]
 122      if type(mcs) == types.ListType or type(mcs) == types.TupleType:
 123        for e in mcs:
 124          if isinstance(e,ASSD):
 125            sd.append(e)
 126            e=e.nom
 127          if d.has_key(e):del d[e]
 128          if self.jdc.sds_dict.has_key(e):del self.jdc.sds_dict[e]
 129      else:
 130        if isinstance(mcs,ASSD):
 131          sd.append(mcs)
 132          mcs=mcs.nom
 133        if d.has_key(mcs):del d[mcs]
 134        if self.jdc.sds_dict.has_key(mcs):del self.jdc.sds_dict[mcs]
 135    for s in sd:
 136      # On signale au parent que le concept s n'existe plus apres l'étape self
 137      self.parent.delete_concept_after_etape(self,s)
 138
 139 def subst_materiau(text,NOM_MATER,EXTRACTION):
 140    """
 141        Cette fonction retourne un texte obtenu à partir du texte passé en argument (text)
 142        en substituant le nom du materiau par NOM_MATER
 143        et en réalisant les extractions spéciifées dans EXTRACTION
 144    """
 145    lines=string.split(text,'\n')
 146    if EXTRACTION:
 147      ll=[]
 148      regmcf=re.compile(r" *(.*) *= *_F\( *## +(.*) +(.*)")
 149      regmcs=re.compile(r" *(.*) *= *([^ ,]*) *, *## +([^ ]*) *([^ ]*)")
 150      regfin=re.compile(r" *\) *")
 151      temps={};lmcf=[]
 152      for e in EXTRACTION:
 153        mcf=e['COMPOR']
 154        lmcf.append(mcf)
 155        temps[mcf]=e['TEMP_EVAL']
 156      FLAG=0
 157      for l in lines:
 158        m=regmcf.match(l)
 159        if m: # On a trouve un mot cle facteur "commentarise"
 160          if m.group(2) == "SUBST": # il est de plus substituable
 161            if temps.has_key(m.group(3)): # Il est a substituer
 162              ll.append(" "+m.group(3)+"=_F(")
 163              mcf=m.group(3)
 164              TEMP=temps[mcf]
 165              FLAG=1 # Indique que l'on est en cours de substitution
 166            else: # Il n est pas a substituer car il n est pas dans la liste demandee
 167              ll.append(l)
 168          else: # Mot cle facteur commentarise non substituable
 169            ll.append(l)
 170        else:  # La ligne ne contient pas un mot cle facteur commentarise
 171          if FLAG == 0: # On n est pas en cours de substitution
 172            ll.append(l)
 173          else: # On est en cours de substitution. On cherche les mots cles simples commentarises
 174            m=regmcs.match(l)
 175            if m: # On a trouve un mot cle simple commentarise
 176              if m.group(3) == "EVAL":
 177                ll.append("  "+m.group(1)+' = EVAL("'+m.group(4)+"("+str(TEMP)+')"),')
 178              elif m.group(3) == "SUPPR":
 179                pass
 180              else:
 181                ll.append(l)
 182            else: # On cherche la fin du mot cle facteur en cours de substitution
 183              m=regfin.match(l)
 184              if m: # On l a trouve. On le supprime de la liste
 185                FLAG=0
 186                del temps[mcf]
 187              ll.append(l)
 188    else:
 189      ll=lines
 190
 191    for l in ll:
 192      print l
 193    lines=ll
 194    ll=[]
 195    for l in lines:
 196      l=re.sub(" *MAT *= *",NOM_MATER+" = ",l,1)
 197      ll.append(l)
 198    text=string.join(ll,'\n')
 199    return text
 200
 201 def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER,
 202                     EXTRACTION,INFO,**args):
 203   """
 204       Fonction sd_prod pour la macro INCLUDE_MATERIAU
 205   """
 206   mat=string.join((NOM_AFNOR,'_',TYPE_MODELE,'_',VARIANTE,'.',TYPE_VALE),'')
 207   if not hasattr(self,'mat') or self.mat != mat:
 208     self.mat=mat
 209     # On récupère le répertoire des matériaux dans les arguments
 210     # supplémentaires du JDC
 211     rep_mat=self.jdc.args["rep_mat"]
 212     f=os.path.join(rep_mat,mat)
 213     if not os.path.isfile(f):
 214        raise "Erreur sur le fichier materiau: "+f
 215     # Les materiaux sont uniquement disponibles en syntaxe Python
 216     # On lit le fichier et on supprime les éventuels \r
 217     text=string.replace(open(f).read(),'\r\n','\n')
 218     # On effectue les substitutions necessaires
 219     self.prefix=NOM_MATER
 220     self.text= subst_materiau(text,NOM_MATER,EXTRACTION)
 221     if INFO == 2:
 222       print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
 223       print self.text
 224     # on execute le texte fourni dans le contexte forme par
 225     # le contexte de l etape pere (global au sens Python)
 226     # et le contexte de l etape (local au sens Python)
 227     # Il faut auparavant l'enregistrer aupres du module linecache (utile pour nommage.py)
 228     linecache.cache[f]=0,0,string.split(self.text,'\n'),f
 229     code=compile(self.text,f,'exec')
 230     if self.jdc.par_lot == 'NON':
 231       # On est en mode commande par commande
 232       # On teste la validite de la commande avec interruption eventuelle
 233       cr=self.report()
 234       self.parent.cr.add(cr)
 235       if not cr.estvide():
 236         raise EOFError
 237       # Et en plus il faut executer la fonction ops014 avant les sous
 238       # commandes car le prefixe PRFXCO doit etre initialise dans le Fortran
 239       self.codex.opsexe(self,0,-1,-self.definition.op)
 240
 241     d={}
 242     self.g_context = d
 243     self.contexte_fichier_init = d
 244     exec code in self.parent.get_global_contexte(),d