Noyau/N_SENSIBILITE.py

   1 #@ MODIF N_SENSIBILITE Noyau  DATE 07/09/2009   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 # RESPONSABLE COURTOIS M.COURTOIS
   4 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   5 # ======================================================================
   6 # COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
   7 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   8 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   9 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
  10 # (AT YOUR OPTION) ANY LATER VERSION.
  11 #
  12 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  13 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  14 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  15 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  16 #
  17 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  18 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  19 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  20 # ======================================================================
  21
  22 """
  23    Ce module contient les règles nécessaires aux commandes sensibles
  24    pour renseigner l'attribut etape.sd.sensi, gérer le caractère réentrant
  25    sur présence de la sensibilité.
  26 """
  27
  28 from types import TupleType, ListType
  29 EnumTypes = (TupleType, ListType)
  30
  31 from N_REGLE import REGLE
  32
  33 # -----------------------------------------------------------------------------
  34 class CONCEPT_SENSIBLE(REGLE):
  35    """Règle permettant de renseigner au niveau du catalogue comment sera
  36    rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
  37    """
  38    def __init__(self, mode, mocle='SENSIBILITE'):
  39       """Constructeur.
  40
  41          mode : manière dont la commande rempli le concept
  42             - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
  43             - 'SEPARE'   : concept nominal OU dérivée (une ou plusieurs)
  44
  45          mocle : mot-clé contenant les paramètres sensibles.
  46       """
  47       REGLE.__init__(self)
  48       self.mocle = mocle
  49       self._modes = { 'ENSEMBLE' : 0, 'SEPARE' : 1 }
  50       self.mode = self._modes.get(mode, self._modes['ENSEMBLE'])
  51
  52    def gettext(self):
  53       """Pour EFICAS
  54       """
  55       return ''
  56
  57    def verif(self, args):
  58       """Retourne texte + 1 si ok, 0 si nook.
  59       On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
  60       renseigne le concept si cela n'a pas déjà été fait (car verif est
  61       appelé à chaque validation).
  62       """
  63       obj = args["self"]
  64       etape = obj.etape
  65       id_etape = '%s_%s' % (etape.id, id(etape))
  66       if etape.sd == None:
  67           return '',1
  68       if not hasattr(etape.sd,"sensi"):
  69          etape.sd.sensi = {}
  70       # si ENSEMBLE, la sd nominale est forcément produite
  71       if self.mode == self._modes['ENSEMBLE'] and not etape.sd.sensi.has_key('nominal'):
  72          etape.sd.sensi['nominal'] = id_etape
  73       # liste des paramètres sensibles
  74       valeur = obj[self.mocle]
  75       if valeur == None:
  76          # pas de sensibilité, la sd nominale est produite
  77          if not etape.sd.sensi.has_key('nominal'):
  78             etape.sd.sensi['nominal'] = id_etape
  79          return '', 1
  80       if not type(valeur) in EnumTypes:
  81          valeur = [valeur,]
  82       for v in valeur:
  83          if not etape.sd.sensi.has_key(v.get_name()):
  84             etape.sd.sensi[v.get_name()] = id_etape
  85       return '', 1
  86
  87
  88 # -----------------------------------------------------------------------------
  89 class REUSE_SENSIBLE(REGLE):
  90    """Limite le caractère réentrant de la commande.
  91    On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
  92    été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
  93       - sd nominale calculée et SENSIBILITE absent
  94       - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
  95    """
  96    def __init__(self, mocle='SENSIBILITE'):
  97       """Constructeur.
  98          mocle : mot-clé SENSIBILITE.
  99       """
 100       REGLE.__init__(self)
 101       self.mocle = mocle
 102
 103    def gettext(self):
 104       """Pour EFICAS
 105       """
 106       return ''
 107
 108    def verif(self,args):
 109       """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
 110       Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation),
 111       on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
 112       """
 113       obj = args["self"]
 114       etape = obj.etape
 115       id_etape = '%s_%s' % (etape.id, id(etape))
 116       sd = etape.sd
 117       # si la commande n'est pas réentrante, rien à faire
 118       if etape.reuse is not None:
 119          valeur = obj[self.mocle]
 120          if valeur is None:
 121             if not hasattr(sd, 'sensi') or sd.sensi.get('nominal', id_etape) != id_etape:
 122                # pas de sensibilite et concept nominal déjà calculé : reuse interdit
 123                text = "Commande non réentrante en l'absence de sensibilité."
 124                return text, 0
 125          else:
 126             if not type(valeur) in EnumTypes:
 127                valeur = [valeur,]
 128             for ps in valeur:
 129                if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape:
 130                   # concept dérivé par rapport à ps déjà calculé : reuse interdit
 131                   text = "Commande non réentrante : dérivée par rapport à %s déjà calculée" % ps.nom
 132                   return text, 0
 133       return '', 1
 134
 135
 136 # -----------------------------------------------------------------------------
 137 class DERIVABLE(REGLE):
 138    """Déclare que le concept fourni derrière un mot-clé est dérivable.
 139    Sa présence ne suffit pas à le valider, il faut encore que son attribut
 140    '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
 141    de celui-ci).
 142    """
 143    def __init__(self, mocle):
 144       """Constructeur.
 145          mocle : mot-clé dérivable.
 146       """
 147       REGLE.__init__(self)
 148       self.mocle = mocle
 149
 150    def gettext(self):
 151       """Pour EFICAS
 152       """
 153       return ''
 154
 155    def verif(self,args):
 156       """
 157       """
 158       obj = args["self"]
 159       try:
 160          concept = obj[self.mocle]
 161       except IndexError:
 162          return '', 1
 163       if not type(concept) in EnumTypes:
 164          concept = [concept,]
 165       l_ps = obj["SENSIBILITE"]
 166       for co in concept:
 167          if co is None:
 168             text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
 169             return text, 0
 170          if not l_ps:
 171             # pas de sensibilité
 172             if hasattr(co,"sensi") and not co.sensi.get('nominal'):
 173                text = "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" %\
 174                      co.nom
 175                return text, 0
 176          else:
 177             # sensibilité spécifiée
 178             if not type(l_ps) in EnumTypes:
 179                l_ps = [l_ps,]
 180             for ps in l_ps:
 181                if not hasattr(co,"sensi") or not co.sensi.get(ps.nom):
 182                   text = "La dérivée de %s par rapport à %s n'est pas disponible." %\
 183                         (co.nom, ps.nom)
 184                   return text, 0
 185       return '', 1
 186