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