Aster/Cata/cataSTA9/SD/sd_resultat.py

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