Aster/Cata/cataSTA9/SD/sd_fonction.py

   1 #@ MODIF sd_fonction SD  DATE 19/02/2008   AUTEUR MACOCCO K.MACOCCO
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2007  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 from SD import *
  22 from SD.sd_titre import sd_titre
  23 from SD.sd_util import *
  24
  25
  26 #----------------------------------------------------------------
  27 # définition de 3 classes :
  28 #  sd_formule        (objets python + jeveux)
  29 #  sd_fonction_aster (objets jeveux)
  30 #  sd_fonction       (chapeau des 2 classes précédentes)
  31 #----------------------------------------------------------------
  32
  33
  34
  35 class sd_formule(AsBase):
  36 #--------------------------------------
  37     nomj = SDNom(fin=19)
  38     PROL = AsVK24(lonmax=6, )
  39     NOVA = AsVK8()
  40
  41
  42 class sd_fonction_aster(sd_titre):
  43 #--------------------------------------
  44     nomj = SDNom(fin=19)
  45     PROL = AsVK24()
  46     VALE = AsObject(acces='NU', sd_stockage='CONTIG', modelong='VARIABLE', type='R', xous=Parmi('S', 'X'), genr='V', ltyp=8, )
  47     PARA = Facultatif(AsVR())
  48
  49     # existence possible de la SD :
  50     def exists(self):
  51         return self.PROL.exists
  52
  53
  54     def check_PROL(self,checker) :
  55     #-------------------------------
  56         if not self.exists() : return
  57
  58         prol=self.PROL.get()
  59         assert prol , self
  60         typfon= prol[0].strip()
  61         assert typfon in ('CONSTANT', 'FONCTION', 'FONCT_C', 'NAPPE', 'INTERPRE')  ,prol
  62        #ltabul = True : la fonction est tabulée (et non interpretée)
  63         ltabul = typfon != 'INTERPRE'
  64
  65         if typfon == 'NAPPE' :
  66             assert len(prol) > 7  , (prol,self)
  67         else :
  68             # tester que le prol[5] est bien le nom de la fonction
  69             assert len(prol) == 6  , (prol,self)
  70
  71         if ltabul :  # type d'interpolation
  72             interp= prol[1].strip()
  73             assert interp[:3] in ('NON', 'LIN', 'LOG') , prol
  74             assert interp[4:] in ('NON', 'LIN', 'LOG') , prol
  75
  76         if ltabul :  # nom d'un paramètre
  77             para=prol[2].strip()
  78             assert para != '', prol
  79
  80         assert prol[3].strip() != ''  , prol  # type du résultat
  81
  82         if ltabul :  # prolongement à droite et à gauche
  83             prolgd=prol[4].strip()
  84             assert len(prolgd)==2, prol
  85             assert prolgd[0] in ('E', 'C', 'L', 'I'), prol
  86             assert prolgd[1] in ('E', 'C', 'L', 'I'), prol
  87
  88         if typfon == 'NAPPE' :
  89             nf= (len(prol) - 7)/2
  90             assert len(prol)==7+2*nf, prol
  91             # 1er paramètre de la nappe
  92             assert prol[6].strip() != ''  , prol
  93
  94             for kf in range(nf):
  95                 interp= prol[6+2*kf+1].strip()
  96                 prolgd= prol[6+2*kf+2].strip()
  97                 assert interp[:3] in ('NON', 'LIN', 'LOG') , prol
  98                 assert interp[4:] in ('NON', 'LIN', 'LOG') , prol
  99                 assert prolgd[0] in ('E', 'C', 'L', 'I'), prol
 100                 assert prolgd[1] in ('E', 'C', 'L', 'I'), prol
 101
 102
 103     def check_VALE(self,checker) :
 104     #-------------------------------
 105         if not self.exists() : return
 106
 107         prol=self.PROL.get()
 108         vale=self.VALE.get()
 109         typfon= prol[0].strip()
 110
 111         if   typfon=='CONSTANT' :
 112             assert len(vale)==2, (vale,self)
 113
 114         elif typfon=='FONCTION' :
 115             nbpt=len(vale)/2
 116             assert len(vale)==2*nbpt, (vale,self)
 117             if nbpt > 1 :
 118                 assert sdu_monotone(vale[:nbpt]) in (1,),(nbpt,vale,self)
 119
 120         elif typfon=='FONCT_C' :
 121             nbpt=len(vale)/3
 122             assert len(vale)==3*nbpt, (vale,self)
 123             if nbpt > 1 :
 124                 # print "AJACOT fonction=",self
 125                 assert sdu_monotone(vale[:nbpt]) in (1,),(nbpt,vale,self)
 126
 127         elif typfon=='NAPPE' :
 128             nbfonc=len(vale.keys())
 129             for k in range(nbfonc):
 130                 val1=vale[k+1]
 131                 nbpt=len(val1)/2
 132                 assert len(val1)==2*nbpt, (val1,self)
 133                 if nbpt > 1 :
 134                     assert sdu_monotone(val1[:nbpt]) in (1,),(nbpt,val1,self)
 135
 136
 137     def check_NAPPE(self,checker) :
 138     #-------------------------------
 139         if not self.exists() : return
 140
 141         prol=self.PROL.get()
 142         typfon= prol[0].strip()
 143         if typfon != 'NAPPE' : return
 144
 145         para=self.PARA.get()
 146         if len(para) > 1 :
 147             assert sdu_monotone(para) in (1,),(para,self)
 148         vale=self.VALE.get()
 149         assert  len(para)==len(vale.keys()),self
 150
 151
 152 class sd_fonction(sd_titre):
 153 #---------------------------
 154     nomj = SDNom(fin=19)
 155     PROL = AsVK24()
 156     NOVA = Facultatif(AsVK8())
 157     VALE = Facultatif(AsObject())
 158     PARA = Facultatif(AsVR())
 159
 160     def check_1(self,checker) :
 161         nom=self.nomj()[:19]
 162         if self.NOVA.exists :
 163             sd2=sd_formule(nom) ; sd2.check()
 164         else :
 165             sd2=sd_fonction_aster(nom) ; sd2.check()
 166