Aster/Cata/cataSTA10/SD/sd_melasflu.py

   1 #@ MODIF sd_melasflu SD  DATE 21/04/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
  23 from SD.sd_l_table import sd_l_table
  24 from SD.sd_table import sd_table
  25 from SD.sd_cham_no import sd_cham_no
  26 from SD.sd_matr_asse_gene import sd_matr_asse_gene
  27 from SD.sd_type_flui_stru import sd_type_flui_stru
  28 from SD.sd_resultat_dyn import sd_resultat_dyn
  29 from SD.sd_util import *
  30
  31
  32 class sd_melasflu(AsBase):
  33 #-------------------------------
  34     nomj = SDNom(fin=8)
  35
  36     MASG = AsVR(SDNom(debut=19), )
  37     VITE = AsVR(SDNom(debut=19), )
  38     REMF = AsVK8(SDNom(debut=19), lonmax=2, )
  39     FREQ = AsVR(SDNom(debut=19), )
  40     NUMO = AsVI(SDNom(debut=19))
  41     FACT = AsVR(SDNom(debut=19), )
  42     DESC = AsVK16(SDNom(debut=19), lonmax=1, )
  43
  44     # si FAISCEAU_TRANS + couplage fluide-structure + BASE_MODALE/AMOR_REDUIT_CONN :
  45     VCN  = Facultatif(AsVR())
  46     VEN  = Facultatif(AsVR())
  47     RAP  = Facultatif(AsVR())
  48
  49     sd_table   = sd_table(SDNom(nomj=''))
  50     sd_l_table = Facultatif(sd_l_table(SDNom(nomj=''))) # Si FAISCEAU_AXIAL
  51
  52
  53     # indirections via .REMF :
  54     #----------------------------------
  55     def check_melasflu_i_REMF(self, checker):
  56         remf=self.REMF.get_stripped()
  57         sd2 = sd_type_flui_stru(remf[0]) ; sd2.check(checker)
  58         sd2 = sd_resultat_dyn(remf[1]) ; sd2.check(checker)
  59
  60
  61     # Vérifications supplémentaires :
  62     #----------------------------------
  63     def check_veri1(self, checker):
  64         remf=self.REMF.get()
  65         desc=self.DESC.get_stripped()
  66
  67         # calcul de itypfl (type d'interaction fluide / structure) :
  68         typfl = sd_type_flui_stru(remf[0])
  69         itypfl=typfl.FSIC.get()[0]  # 1 -> FAISCEAU_TRANS
  70                                     # 3 -> FAISCEAU_AXIAL
  71         couplage=typfl.FSIC.get()[1]  # 1 -> prise en compte du couplage
  72         assert itypfl > 0 , remf
  73
  74         # calcul de nbmode (nombre de modes) :
  75         nbmode=self.NUMO.lonmax
  76         assert nbmode > 0
  77
  78         # calcul de nbvite (nombre de vitesses) :
  79         nbvite=self.VITE.lonmax
  80         assert nbvite > 0
  81
  82         # vérification de l'objet .DESC :
  83         #--------------------------------
  84         assert len(desc)==1 , desc
  85         assert desc[0] == 'DEPL' , desc
  86
  87         # vérification de l'objet .NUMO :
  88         #--------------------------------
  89         for x in self.NUMO.get() :
  90             assert x >= 1 , numo
  91
  92         # vérification de l'objet .FACT :
  93         #--------------------------------
  94         if itypfl==3 :  # faisceau axial
  95             assert self.FACT.lonmax == 3*nbmode*nbvite
  96         else :
  97             assert self.FACT.lonmax == 3*nbmode
  98
  99         # vérification de l'objet .MASG :
 100         #--------------------------------
 101         if itypfl==3 :  # faisceau axial
 102             assert self.MASG.lonmax == nbmode*nbvite
 103         else :
 104             assert self.MASG.lonmax == nbmode
 105
 106         # vérification de l'objet .FREQ :
 107         #--------------------------------
 108         assert self.FREQ.lonmax == 2*nbmode*nbvite
 109
 110         # vérification existence .VCN et .VEN:
 111         #-------------------------------------
 112         if self.VCN.exists : assert self.VEN.exists
 113         if self.VEN.exists : assert self.VCN.exists
 114         if self.VEN.exists : assert itypfl == 1 and couplage == 1
 115         if self.RAP.exists : assert (self.VEN.exists and self.VCN.exists)
 116
 117         # vérification de l'objet .VCN :
 118         #--------------------------------
 119         if self.VCN.exists :
 120             fsvi=typfl.FSVI.get()
 121             nbzone=fsvi[1]
 122             nbval=0
 123             for i in range(nbzone) :
 124                 nbval=nbval+fsvi[2+nbzone+i]
 125             assert self.VCN.lonmax == nbmode*nbval*2
 126
 127         # vérification de l'objet .VEN :
 128         #--------------------------------
 129         if self.VEN.exists :
 130             assert self.VEN.lonmax == nbmode*2
 131
 132         # vérification de l'objet .RAP :
 133         #--------------------------------
 134         if self.RAP.exists :
 135             fsvi=typfl.FSVI.get()
 136             nbzone=fsvi[1]
 137             nbval=0
 138             for i in range(nbzone) :
 139                 nbval=nbval+fsvi[2+nbzone+i]
 140             assert self.RAP.lonmax == nbmode*nbval*2
 141
 142         # vérification de la SD table contenant les cham_no :
 143         #----------------------------------------------------
 144         tcham=self.sd_table
 145         assert tcham.nb_column() == 1  , tcham
 146         col1=tcham.get_column_name('NOM_CHAM')
 147         assert col1, "Il manque la colonne NOM_CHAM"
 148
 149         data=col1.data.get()
 150         mask=col1.mask.get()
 151         profchno=''
 152         for k in range(len(mask)):
 153             if not mask[k] : continue
 154             ch1=sd_cham_no(data[k])
 155             ch1.check(checker)
 156
 157             # Tous les cham_no doivent avoir le meme prof_chno :
 158             profchn1=ch1.REFE.get()[1]
 159             if profchno == '':
 160                 profchno=profchn1
 161             else:
 162                 assert profchn1 == profchno  ,(profchn1, profchno)
 163
 164
 165         # vérification de la SD l_table :
 166         #--------------------------------
 167         if self.sd_l_table.LTNT.exists : assert itypfl == 3   # FAISCEAU_AXIAL
 168         if itypfl == 3  : assert self.sd_l_table.LTNT.exists
 169
 170         if self.sd_l_table.LTNT.exists :
 171             l_table = self.sd_l_table
 172             l_table.check(checker)
 173
 174             # la l_table ne contient qu'une seule table nommée 'MATR_GENE'
 175             sdu_compare(l_table.LTNT,checker,l_table.LTNT.lonuti,'==',1,"LONUTI(LTNT)==1")
 176             sdu_compare(l_table.LTNT,checker,l_table.LTNT.get()[0].strip(),'==','MATR_GENE',"LTNT[0]==MATR_GENE")
 177
 178             # vérification de la table 'MATR_GENE' :
 179             tmatgen=sd_table(l_table.LTNS.get()[0])
 180             col1=tmatgen.get_column_name('NUME_VITE')
 181             sdu_assert(None, checker, col1, "Manque colonne NUME_VITE")
 182             col1=tmatgen.get_column_name('VITE_FLUI')
 183             sdu_assert(None, checker, col1, "Manque colonne VITE_FLUI")
 184
 185             for x in 'MATR_RIGI', 'MATR_MASS', 'MATR_AMOR' :
 186                 col1=tmatgen.get_column_name(x)
 187                 sdu_assert(None, checker, col1, "Manque colonne : "+x)
 188                 data=col1.data.get()
 189                 mask=col1.mask.get()
 190                 for k in range(len(mask)):
 191                     if not mask[k] : continue
 192                     matgen=sd_matr_asse_gene(data[k])
 193                     matgen.check(checker)
 194
 195