Aster/Cata/cataSTA9/SD/sd_resultat.py

   1 #@ MODIF sd_resultat SD  DATE 22/10/2007   AUTEUR PELLET J.PELLET
   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
  24 from SD.sd_l_table import sd_l_table
  25 from SD.sd_champ import sd_champ
  26 from SD.sd_l_charges import sd_l_charges
  27 from SD.sd_char_contact import sd_char_contact
  28 from sets import Set
  29 from SD.sd_util import *
  30
  31
  32 class sd_resultat(sd_titre):
  33 #---------------------------------------
  34     nomj = SDNom(fin=8)
  35     TAVA = AsColl(SDNom(debut=19), acces='NU', stockage='CONTIG', modelong='CONSTANT', type='K', ltyp=8, )
  36     NOVA = AsObject(SDNom(debut=19), genr='N', xous='S', type='K', ltyp=16, )
  37     TACH = AsColl(SDNom(debut=19), acces='NU', stockage='CONTIG', modelong='CONSTANT', type='K', ltyp=24, )
  38     ORDR = AsVI(SDNom(debut=19), )
  39     DESC = AsObject(SDNom(debut=19), genr='N', xous='S', type='K', ltyp=16, )
  40
  41     # la déclaration suivante simplifie la fonction check_resultat_i_char
  42     CHAR = Facultatif(AsVK24(SDNom(debut=19),))
  43
  44     sd_l_table = Facultatif(sd_l_table(SDNom(nomj='')))
  45
  46
  47     # existence de la SD :
  48     def exists(self):
  49         return self.ORDR.exists
  50
  51
  52     # indirection vers les champs de .TACH :
  53     def check_resultat_i_TACH(self, checker):
  54         tach = self.TACH.get()
  55         for nosym in tach.keys():
  56             for nom in tach[nosym] :
  57                 if not nom.strip(): continue
  58                 sd2 = sd_champ(nom)
  59                 sd2.check(checker)
  60
  61
  62     # indirection vers les objets de .TAVA :
  63     def check_resultat_i_TAVA(self, checker):
  64         tava = self.TAVA.get()
  65         S1=Set()
  66         for knova in tava.keys():
  67             suffix=tava[knova][0][:5]
  68             if not suffix.strip(): continue       # JP : est-ce possible ?
  69             S1.add(suffix)
  70         for suffix in S1 :
  71             nom=self.nomj()[:19]+suffix
  72             sd2 = AsObject(SDNom(nomj=nom,debut=0), xous='S', genr='V', type=Parmi('I','R','C','K'),
  73                            ltyp=Parmi(4,8,16,24),) ; sd2.check(checker)
  74
  75
  76     # indirection vers les sd_l_charges stockées comme paramètres dans l'objet .CHAR :
  77     def check_resultat_i_CHAR(self, checker):
  78         lnom = self.CHAR.get()
  79         if not lnom: return
  80         S1=Set()
  81         for nom in lnom:
  82             if not nom.strip(): continue
  83             S1.add(nom)
  84         for nom in S1 :
  85             sd2 = sd_l_charges(nomj=nom); sd2.check(checker)
  86
  87
  88     # vérification de .ORDR :
  89     def check_ORDR(self, checker):
  90         V = self.ORDR
  91         nuti=V.lonuti
  92         nmax=V.lonmax
  93         sdu_compare(V, checker, nuti, '> ', 0   , comment='nuti > 0')
  94         sdu_compare(V, checker, nuti, '<=', nmax, comment='nuti <= nmax')
  95
  96         # les numeros d'ordre doivent etre tous différents :
  97         sdu_tous_differents(V,checker,V.get()[:nuti],'1:NUTI')
  98
  99
 100     # vérification des longueurs des différents objets :
 101     def check_LONGUEURS(self, checker):
 102         ordr = self.ORDR.get()
 103         tach = self.TACH.get()
 104         nova = self.NOVA.get()
 105         tava = self.TAVA.get()
 106         desc = self.DESC.get()
 107
 108         nbmax_ordr=len(ordr)   # la SD est concue pour stocker jusqu'à nbmax_ordr nume_ordre
 109         nbmax_para=len(nova)   # la SD est concue pour stocker jusqu'à nbmax_para paramètres
 110         nbmax_nosym=len(desc)  # la SD est concue pour stocker jusqu'à nbmax_nosym nom_cham
 111
 112         sdu_compare(self.TACH,checker,len(tach),'==',nbmax_nosym,'Incohérence TACH/DESC')
 113         sdu_compare(self.TAVA,checker,len(tava),'==',nbmax_para, 'Incohérence TAVA/NOVA')
 114
 115         # .TACH
 116         for ksym in tach.keys():
 117             nosym=desc[ksym-1].strip()
 118             sdu_compare(self.TACH,checker,len(tach[ksym]),'==',nbmax_ordr,nosym+' LONMAX(.TACH) != LONMAX(.ORDR)')
 119
 120
 121         # objets trouvés dans .TAVA
 122         for knova in tava.keys():
 123             sdu_compare(tava,checker,len(tava[knova]),'==',4,'LONMAX(TAVA[ksym]==4')
 124             suffix=tava[knova][0][:5]
 125             npara=int(tava[knova][2])
 126             if not suffix.strip(): continue
 127             nom=self.nomj()[:19]+suffix
 128             sd2 = AsObject(SDNom(nomj=nom,debut=0), xous='S', genr='V', type=Parmi('I','R','C','K'),
 129                            ltyp=Parmi(4,8,16,24),)
 130             sdu_compare(sd2,checker,len(sd2.get()),'==',npara*nbmax_ordr,'Incohérence LONMAX / LONMAX(.ORDR)')
 131
 132
 133     # vérification que les variables d'accès sont bien différentes :
 134     def check_ACCES(self, checker):
 135         ordr = self.ORDR.get()
 136         nova = self.NOVA.get()
 137         tava = self.TAVA.get()
 138
 139         nbmax_ordr=len(ordr)        # la SD est concue pour stocker jusqu'à nbmax_ordr nume_ordre
 140         nbuti_ordr=self.ORDR.lonuti # la SD contient réellement nbuti_ordr nume_ordre
 141
 142
 143         # objets trouvés dans .TAVA
 144         for knova in tava.keys():
 145             nova1=nova[knova-1]
 146             suffix=tava[knova][0][:5]
 147             if not suffix.strip(): continue
 148
 149             nupara=int(tava[knova][1])
 150             nbpara=int(tava[knova][2])
 151             acces=tava[knova][3].strip()
 152             assert acces in ('PARA','ACCES') , acces
 153             if acces == 'ACCES' :
 154                 # pour l'instant, on ne vérifie que 'INST' car 'FREQ', 'NUME_MODE', 'NOEUD_CMP' ne semblent pas tous différents ...
 155                 if nova1.strip() != 'INST' : continue
 156                 sdu_compare(tava,checker,nupara,'<=',nbpara,'nupara <= nbpara')
 157
 158                 nom=self.nomj()[:19]+suffix
 159                 sd2 = AsObject(SDNom(nomj=nom,debut=0),)
 160                 vect=sd2.get()
 161                 seq=[]
 162                 for k in range(nbuti_ordr) :
 163                     seq.append(vect[k*nbpara+nupara-1])
 164
 165                 sdu_tous_differents(sd2,checker,seq,nova1)
 166
 167