Extensions/parametre.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  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 # ======================================================================
  21 """
  22     Ce module contient la classe PARAMETRE qui sert à définir
  23     des objets paramètres qui sont compréhensibles et donc affichables
  24     par EFICAS.
  25     Ces objets sont créés à partir de la modification du fichier de commandes
  26     de l'utilisateur par le parseur de fichiers Python
  27 """
  28
  29 # import de modules Python
  30 import string,types
  31 from math import *
  32
  33 # import de modules Eficas
  34 from Noyau.N_CR import CR
  35 from Noyau import N_OBJECT
  36 from Ihm import I_OBJECT
  37
  38 class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
  39   """
  40      Cette classe permet de créer des objets de type PARAMETRE
  41      cad des affectations directes dans le jeu de commandes (ex: a=10.)
  42      qui sont interprétées par le parseur de fichiers Python.
  43      Les objets ainsi créés constituent des paramètres pour le jdc
  44   """
  45
  46   nature = 'PARAMETRE'
  47   idracine = 'param'
  48
  49   def __init__(self,nom,valeur=None):
  50     # parent ne peut être qu'un objet de type JDC
  51     self.dict_valeur=[]
  52     self.valeur = self.interprete_valeur(valeur)
  53     self.val=valeur
  54     self.nom = nom
  55     # La classe PARAMETRE n'a pas de définition : on utilise self pour
  56     # complétude
  57     self.definition=self
  58     self.jdc = self.parent = CONTEXT.get_current_step()
  59     self.niveau=self.parent.niveau
  60     self.actif=1
  61     self.state='undetermined'
  62     self.register()
  63
  64   def __getitem__(self,key):
  65     param_item=ITEM_PARAMETRE(self,key)
  66     return param_item
  67
  68   def __neg__(self):
  69     try:
  70       return -1*self.valeur
  71     except:
  72       print "******* Probleme : pas de valeur négative"
  73       return None
  74
  75   def __add__(self,a):
  76     try :
  77       return self.valeur+a.valeur
  78     except :
  79       print "******* Probleme : a l addition"
  80       return None
  81
  82   def __radd__(self,a):
  83     try :
  84       return self.valeur+a.valeur
  85     except :
  86       print "******* Probleme : a l addition"
  87       return None
  88
  89   def __sub__(self,a):
  90     try :
  91       return self.valeur  - a.valeur
  92     except :
  93       print "******* Probleme : a la soustraction"
  94       return None
  95
  96   def __rsub__(self,a):
  97     try :
  98       return a.valeur - self.valeur
  99     except :
 100       print "******* Probleme : a la soustraction"
 101       return None
 102
 103
 104   def __mul__(self,a):
 105     try :
 106       return self.valeur*a.valeur
 107     except :
 108       print "******* Probleme : a la multiplication"
 109       return None
 110
 111   def __rmul__(self,a):
 112     try :
 113       return self.valeur*a.valeur
 114     except :
 115       print "******* Probleme : a la multiplication"
 116       return None
 117
 118   def __add__(self,other):
 119     try :
 120       return self.valeur+other
 121     except :
 122       print "******* Probleme : a l addition"
 123       return None
 124
 125   def __radd__(self,other):
 126     try :
 127       return self.valeur+other
 128     except :
 129       print "******* Probleme : a l addition"
 130       return None
 131
 132   def __sub__(self,other):
 133     try :
 134       return self.valeur  - other
 135     except :
 136       print "******* Probleme : a la soustraction"
 137       return None
 138
 139   def __rsub__(self,other):
 140     try :
 141       return other - self.valeur
 142     except :
 143       print "******* Probleme : a la soustraction"
 144       return None
 145
 146   def  __mul__ (self,other):
 147     retour=None
 148     try :
 149       retour = eval(self.valeur) * other
 150     except :
 151       try :
 152          retour = self.valeur * other
 153       except :
 154          try :
 155            retour = eval(self.valeur) * eval(other)
 156          except :
 157            try :
 158              retour = self.valeur * eval(other)
 159            except :
 160              print other
 161              print "******* Probleme : a la multiplication _mul__"
 162     return retour
 163
 164   def __rmul__ (self,other):
 165     retour=None
 166     try :
 167       retour = eval(self.valeur) * other
 168     except :
 169       try :
 170          retour = self.valeur * other
 171       except :
 172          try :
 173             retour = eval(self.valeur) * eval(other)
 174          except :
 175             print "******* Probleme : a la multiplication __rmul__"
 176     return retour
 177
 178
 179   def __div__(self,other):
 180     retour=None
 181     try:
 182       retour = eval(self.valeur) / other
 183     except :
 184       try :
 185         retour = self.valeur / other
 186       except :
 187         print "******* Probleme : a la division"
 188     return retour
 189
 190
 191   def cos(self):
 192       try :
 193         retour=cos(self.valeur)
 194         return retour
 195       except:
 196         print "pb pour cosinus"
 197
 198   def sin(self):
 199       try :
 200         retour=sin(self.valeur)
 201         return retour
 202       except:
 203         print "pb pour sinus"
 204
 205   def tan(self):
 206       try :
 207         retour=tan(self.valeur)
 208         return retour
 209       except:
 210         print "pb pour tangente"
 211
 212   def log(self):
 213       try :
 214         retour=log(self.valeur)
 215         return retour
 216       except:
 217         print "pb pour log"
 218
 219   def sqrt(self):
 220       try :
 221         retour=sqrt(self.valeur)
 222         return retour
 223       except:
 224         print "pb pour sqrt"
 225
 226   def interprete_valeur(self,val):
 227     """
 228     Essaie d'interpréter val (chaîne de caractères)comme :
 229     - un entier
 230     - un réel
 231     - une chaîne de caractères
 232     - une liste d'items d'un type qui précède
 233     Retourne la valeur interprétée
 234     """
 235     if not val : return None
 236     valeur = None
 237     #  on vérifie si val est un entier
 238     try :
 239         valeur = string.atoi(val)       # on a un entier
 240         return valeur
 241     except :
 242         pass
 243     #  on vérifie si val est un réel
 244     try:
 245         valeur = string.atof(val)   # on a un réel
 246         return valeur
 247     except :
 248         pass
 249     # on vérifie si val est un tuple
 250     try :
 251         valeur = eval(val)
 252     except:
 253         pass
 254     #PN je n ose pas modifier je rajoute
 255     if valeur != None :
 256         if type(valeur) == types.TupleType:
 257             l_new_val = []
 258             typ = None
 259             for v in valeur :
 260                 if not typ:
 261                     typ = type(v)
 262                 else:
 263                     if type(v) != typ :
 264                         # la liste est hétérogène --> on refuse d'interpréter
 265                         #  self comme une liste
 266                         # on retourne la string initiale
 267                         print 'liste hétérogène ',val
 268                         return val
 269                 l_new_val.append(v)
 270             return tuple(l_new_val)
 271         # PN : commente le print
 272         #else:
 273             # on a réussi à évaluer val en autre chose qu'un tuple ...
 274             #print "on a réussi à évaluer %s en autre chose qu'un tuple ..." %val
 275             #print 'on trouve : ',str(valeur),' de type : ',type(valeur)
 276     # on retourne val comme une string car on n'a pas su l'interpréter
 277     if valeur != None :
 278        if type(valeur).__name__ == 'list':
 279           self.dict_valeur=[]
 280           for i in range(len(valeur)):
 281               self.dict_valeur.append(valeur[i])
 282     return val
 283
 284   def get_valeurs(self):
 285     valeurretour=[]
 286     if self.dict_valeur != []:
 287        for val in self.dict_valeur:
 288            valeurretour.append(val)
 289     else:
 290         valeurretour.append(self.valeur)
 291     return valeurretour
 292
 293   def set_valeur(self,new_valeur):
 294     """
 295     Remplace la valeur de self par new_valeur interprétée
 296     """
 297     self.valeur = self.interprete_valeur(new_valeur)
 298     self.init_modif()
 299
 300   def init_modif(self):
 301     """
 302     Méthode qui déclare l'objet courant comme modifié et propage
 303     cet état modifié à ses ascendants
 304     """
 305     self.state = 'modified'
 306     if self.parent:
 307       self.parent.init_modif()
 308
 309   def get_jdc_root(self):
 310     if self.parent:
 311       return self.parent.get_jdc_root()
 312     else:
 313       return self
 314
 315   def register(self):
 316     """
 317     Enregistre le paramètre dans la liste des étapes de son parent (JDC)
 318     """
 319     self.parent.register_parametre(self)
 320     self.parent.register(self)
 321
 322   def isvalid(self,cr='non'):
 323     """
 324     Retourne 1 si self est valide, 0 sinon
 325     Un paramètre est considéré comme valide si :
 326       - il a un nom
 327       - il a une valeur
 328     """
 329     if self.nom == '' :
 330         if cr == 'oui':
 331            self.cr.fatal("Pas de nom donné au paramètre ")
 332         return 0
 333     else:
 334         if self.valeur == None :
 335             if cr == 'oui' :
 336                self.cr.fatal("Le paramètre %s ne peut valoir None" % self.nom)
 337             return 0
 338     return 1
 339
 340   def isoblig(self):
 341     """
 342     Indique si self est obligatoire ou non : retourne toujours 0
 343     """
 344     return 0
 345
 346   def isrepetable(self):
 347     """
 348     Indique si self est répétable ou non : retourne toujours 1
 349     """
 350     return 1
 351
 352   def liste_mc_presents(self):
 353     return []
 354
 355   def supprime(self):
 356     """
 357     Méthode qui supprime toutes les boucles de références afin que
 358     l'objet puisse être correctement détruit par le garbage collector
 359     """
 360     self.parent = None
 361     self.jdc = None
 362     self.definition=None
 363
 364   def active(self):
 365     """
 366     Rend l'etape courante active.
 367     Il faut ajouter le paramètre au contexte global du JDC
 368     """
 369     self.actif = 1
 370     try:
 371         self.jdc.append_param(self)
 372     except:
 373         pass
 374
 375   def inactive(self):
 376     """
 377     Rend l'etape courante inactive
 378     Il faut supprimer le paramètre du contexte global du JDC
 379     """
 380     self.actif = 0
 381     self.jdc.del_param(self)
 382     self.jdc.delete_concept_after_etape(self,self)
 383
 384   def isactif(self):
 385     """
 386     Booléenne qui retourne 1 si self est actif, 0 sinon
 387     """
 388     return self.actif
 389
 390   def set_attribut(self,nom_attr,new_valeur):
 391     """
 392     Remplace la valeur de self.nom_attr par new_valeur)
 393     """
 394     if hasattr(self,nom_attr):
 395       setattr(self,nom_attr,new_valeur)
 396       self.init_modif()
 397
 398   def supprime_sdprods(self):
 399     """
 400     Il faut supprimer le paramètre qui a été entré dans la liste des
 401     paramètres du JDC
 402     """
 403     self.jdc.delete_param(self)
 404
 405   def update_context(self,d):
 406     """
 407     Update le dictionnaire d avec le paramètre que produit self
 408     """
 409     d[self.nom]=self
 410
 411   def __repr__(self):
 412     """
 413         Donne un echo de self sous la forme nom = valeur
 414     """
 415     return self.nom+' = '+str(self.valeur)
 416
 417   def __str__(self):
 418     """
 419         Retourne le nom du paramètre comme représentation de self
 420     """
 421     return self.nom
 422
 423   def get_sdprods(self,nom_sd):
 424      """
 425          Retourne les concepts produits par la commande
 426      """
 427      return None
 428
 429   def report(self):
 430     """ Génère l'objet rapport (classe CR) """
 431     self.cr=CR()
 432     self.isvalid(cr='oui')
 433     return self.cr
 434
 435   def ident(self):
 436     """
 437     Retourne le nom interne associé à self
 438     Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 439     """
 440     return self.nom
 441
 442   def delete_concept(self,sd):
 443     pass
 444
 445   def replace_concept(self,old_sd,sd):
 446     pass
 447
 448   def verif_condition_bloc(self):
 449     """
 450         Evalue les conditions de tous les blocs fils possibles
 451         (en fonction du catalogue donc de la définition) de self et
 452         retourne deux listes :
 453           - la première contient les noms des blocs à rajouter
 454           - la seconde contient les noms des blocs à supprimer
 455     """
 456     return [],[]
 457
 458   def verif_condition_regles(self,liste_presents):
 459     """
 460         Retourne la liste des mots-clés à rajouter pour satisfaire les règles
 461         en fonction de la liste des mots-clés présents
 462     """
 463     return []
 464
 465   def verif_existence_sd(self):
 466      pass
 467
 468   def control_sdprods(self,d):
 469       """sans objet """
 470       pass
 471
 472   def close(self):
 473       pass
 474
 475
 476 class COMBI_PARAMETRE :
 477   def __init__(self,chainevaleur,valeur):
 478       self.chainevaleur=chainevaleur
 479       self.valeur=valeur
 480
 481   def __repr__(self):
 482       return self.chainevaleur
 483
 484   def isvalid(self):
 485       if self.valeur and self.chainevaleur:
 486          return 1
 487
 488 class ITEM_PARAMETRE :
 489   def __init__(self,param_pere,item=None):
 490       self.param_pere = param_pere
 491       self.item = item
 492
 493
 494   def __repr__(self):
 495     return self.param_pere.nom+'['+str(self.item)+']'
 496
 497
 498   def isvalid(self):
 499       isvalid = 1
 500       if self.item < 0:
 501          isvalid =  0
 502       try:
 503          longueur= len(self.param_pere.dict_valeur) - 1
 504       except:
 505          longueur=0
 506       if self.item > longueur :
 507          isvalid= 0
 508       return isvalid