Noyau/N_SENSIBILITE.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19
  20 """
  21    Ce module contient les règles nécessaires aux commandes sensibles
  22    pour renseigner l'attribut etape.sd.sensi, gérer le caractère réentrant
  23    sur présence de la sensibilité.
  24 """
  25
  26 from __future__ import absolute_import
  27
  28 from .N_REGLE import REGLE
  29
  30 # -----------------------------------------------------------------------------
  31 class CONCEPT_SENSIBLE(REGLE):
  32     """Règle permettant de renseigner au niveau du catalogue comment sera
  33     rempli le concept (valeur nominale ou dérivée(s) ou les deux...).
  34     """
  35     def __init__(self, mode, mocle='SENSIBILITE'):
  36         """Constructeur.
  37
  38            mode : manière dont la commande rempli le concept
  39               - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe
  40               - 'SEPARE'   : concept nominal OU dérivée (une ou plusieurs)
  41
  42            mocle : mot-clé contenant les paramètres sensibles.
  43         """
  44         REGLE.__init__(self)
  45         self.mocle = mocle
  46         self._modes = { 'ENSEMBLE' : 0, 'SEPARE' : 1 }
  47         self.mode = self._modes.get(mode, self._modes['ENSEMBLE'])
  48
  49     def getText(self):
  50         """Pour EFICAS
  51         """
  52         return ''
  53
  54     def verif(self, args):
  55         """Retourne texte + 1 si ok, 0 si nook.
  56         On stocke dans sd.sensi l'étape courante, c'est-à-dire celle qui
  57         renseigne le concept si cela n'a pas déjà été fait (car verif est
  58         appelé à chaque validation).
  59         """
  60         obj = args["self"]
  61         etape = obj.etape
  62         id_etape = '%s_%s' % (etape.id, id(etape))
  63         if etape.sd == None:
  64             return '',1
  65         if not hasattr(etape.sd,"sensi"):
  66             etape.sd.sensi = {}
  67         # si ENSEMBLE, la sd nominale est forcément produite
  68         if self.mode == self._modes['ENSEMBLE'] and not 'nominal' in etape.sd.sensi :
  69             etape.sd.sensi['nominal'] = id_etape
  70         # liste des paramètres sensibles
  71         valeur = obj[self.mocle]
  72         if valeur == None:
  73             # pas de sensibilité, la sd nominale est produite
  74             if not 'nominal' in etape.sd.sensi:
  75                 etape.sd.sensi['nominal'] = id_etape
  76             return '', 1
  77         if not type(valeur) in (list, tuple):
  78             valeur = [valeur,]
  79         for v in valeur:
  80             if not v.getName() in etape.sd.sensi:
  81                 etape.sd.sensi[v.getName()] = id_etape
  82         return '', 1
  83
  84
  85 # -----------------------------------------------------------------------------
  86 class REUSE_SENSIBLE(REGLE):
  87     """Limite le caractère réentrant de la commande.
  88     On autorisera reuse seulement si le concept (au sens fortran) n'a pas déjà
  89     été calculé (d'après sd.sensi). Ce sera interdit dans les cas suivants :
  90        - sd nominale calculée et SENSIBILITE absent
  91        - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée
  92     """
  93     def __init__(self, mocle='SENSIBILITE'):
  94         """Constructeur.
  95            mocle : mot-clé SENSIBILITE.
  96         """
  97         REGLE.__init__(self)
  98         self.mocle = mocle
  99
 100     def getText(self):
 101         """Pour EFICAS
 102         """
 103         return ''
 104
 105     def verif(self,args):
 106         """Retourne texte + 1 si ok, 0 si nook = reuse interdit.
 107         Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation),
 108         on regarde si sd.sensi[ps] a été renseigné par une étape précédente.
 109         """
 110         obj = args["self"]
 111         etape = obj.etape
 112         id_etape = '%s_%s' % (etape.id, id(etape))
 113         sd = etape.sd
 114         # si la commande n'est pas réentrante, rien à faire
 115         if etape.reuse is not None:
 116             valeur = obj[self.mocle]
 117             if valeur is None:
 118                 if not hasattr(sd, 'sensi') or sd.sensi.get('nominal', id_etape) != id_etape:
 119                     # pas de sensibilite et concept nominal déjà calculé : reuse interdit
 120                     text = "Commande non réentrante en l'absence de sensibilité."
 121                     return text, 0
 122             else:
 123                 if not type(valeur) in (list, tuple):
 124                     valeur = [valeur,]
 125                 for ps in valeur:
 126                     if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape:
 127                         # concept dérivé par rapport à ps déjà calculé : reuse interdit
 128                         text = "Commande non réentrante : dérivée par rapport à %s déjà calculée" % ps.nom
 129                         return text, 0
 130         return '', 1
 131
 132
 133 # -----------------------------------------------------------------------------
 134 class DERIVABLE(REGLE):
 135     """Déclare que le concept fourni derrière un mot-clé est dérivable.
 136     Sa présence ne suffit pas à le valider, il faut encore que son attribut
 137     '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence
 138     de celui-ci).
 139     """
 140     def __init__(self, mocle):
 141         """Constructeur.
 142            mocle : mot-clé dérivable.
 143         """
 144         REGLE.__init__(self)
 145         self.mocle = mocle
 146
 147     def getText(self):
 148         """Pour EFICAS
 149         """
 150         return ''
 151
 152     def verif(self,args):
 153         """
 154         """
 155         obj = args["self"]
 156         try:
 157             concept = obj[self.mocle]
 158         except IndexError:
 159             return '', 1
 160         if not type(concept) in (list, tuple):
 161             concept = [concept,]
 162         l_ps = obj["SENSIBILITE"]
 163         for co in concept:
 164             if co is None:
 165                 text = "Concept non défini (None) sous le mot-clé %s" % self.mocle
 166                 return text, 0
 167             if not l_ps:
 168                 # pas de sensibilité
 169                 if hasattr(co,"sensi") and not co.sensi.get('nominal'):
 170                     text = "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" %\
 171                           co.nom
 172                     return text, 0
 173             else:
 174                 # sensibilité spécifiée
 175                 if not type(l_ps) in (list, tuple):
 176                     l_ps = [l_ps,]
 177                 for ps in l_ps:
 178                     if not hasattr(co,"sensi") or not co.sensi.get(ps.nom):
 179                         text = "La dérivée de %s par rapport à %s n'est pas disponible." %\
 180                               (co.nom, ps.nom)
 181                         return text, 0
 182         return '', 1