Aster/Cata/cataSTA6/ops.py

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