src/Tools/Verima/Base/dataBase.py

   1 import os
   2 import datetime
   3 import sys
   4
   5 from qtsalome import QSqlQuery, QSqlDatabase
   6 from Base.tableMaillages  import TableMaillages
   7 from Base.tableMailleurs  import TableMailleurs
   8 from Base.tableMachines   import TableMachines
   9 from Base.tableVersions   import TableVersions
  10 from Base.tableGroupesRef import TableGroupesRef
  11 from Base.tableGroupes    import TableGroupes
  12 from Base.tableMailles    import TableMailles
  13 from Base.tableTailles    import TableTailles
  14 from Base.tableRatios     import TableRatios
  15 from Base.tableGroupeRatios     import TableGroupeRatios
  16 from Base.tableGroupeTailles    import TableGroupeTailles
  17 from Base.tablePerfs      import TablePerfs
  18 from Stats.job       import Job
  19 from CreeDocuments.jobHtml       import Document
  20
  21
  22 class Base:
  23   def __init__(self,file):
  24        self.db  = QSqlDatabase.addDatabase("QSQLITE")
  25        self.db.setDatabaseName(file)
  26        self.db.setHostName("localhost");
  27        self.db.setUserName("");
  28        self.db.setPassword("")
  29        if not self.db.open():
  30          print((self.db.lastError().text()))
  31        else:
  32          print("dataBase Open")
  33        self.file=file
  34
  35   def create(self):
  36       self.maTableMailleurs=TableMailleurs()
  37       self.maTableMailleurs.createSqlTable()
  38       self.maTableMachines=TableMachines()
  39       self.maTableMachines.createSqlTable()
  40       self.maTableVersions=TableVersions()
  41       self.maTableVersions.createSqlTable()
  42       self.maTableMaillages=TableMaillages()
  43       self.maTableMaillages.createSqlTable()
  44       self.maTableGroupesRef=TableGroupesRef()
  45       self.maTableGroupesRef.createSqlTable()
  46       self.maTablePerfs=TablePerfs()
  47       self.maTablePerfs.createSqlTable()
  48       self.maTableMailles=TableMailles()
  49       self.maTableMailles.createSqlTable()
  50       self.maTableTailles=TableTailles()
  51       self.maTableTailles.createSqlTable()
  52       self.maTableGroupes=TableGroupes()
  53       self.maTableGroupes.createSqlTable()
  54       self.maTableRatios=TableRatios()
  55       self.maTableRatios.createSqlTable()
  56       self.maTableGroupeRatios=TableGroupeRatios()
  57       self.maTableGroupeRatios.createSqlTable()
  58       self.maTableGroupeTailles=TableGroupeTailles()
  59       self.maTableGroupeTailles.createSqlTable()
  60
  61   def initialise(self):
  62       self.maTableMaillages=TableMaillages()
  63       self.maTableMailleurs=TableMailleurs()
  64       self.maTableVersions=TableVersions()
  65       self.maTableMachines=TableMachines()
  66       self.maTableMailles=TableMailles()
  67       self.maTableTailles=TableTailles()
  68       self.maTableGroupes=TableGroupes()
  69       self.maTableGroupesRef=TableGroupesRef()
  70       self.maTablePerfs=TablePerfs()
  71       self.maTableRatios=TableRatios()
  72       self.maTableGroupeRatios=TableGroupeRatios()
  73       self.maTableGroupeTailles=TableGroupeTailles()
  74
  75   def remplit(self):
  76       self.maTableMailleurs.remplit()
  77       self.maTableMaillages.remplit()
  78       self.maTableVersions.remplit()
  79       self.maTableMachines.creeMachine()
  80       self.maTableGroupesRef.remplit()
  81
  82   def close(self):
  83        self.db.close()
  84
  85   def exportToCSV(self,partiel):
  86       aujourdhui=datetime.date.today()
  87       monFolder="ExportDB"+str(aujourdhui)
  88       try :
  89         os.mkdir(monFolder)
  90       except :
  91         pass
  92       self.maTableMachines.exportToCSV()
  93       self.maTableMailles.exportToCSV()
  94       self.maTableTailles.exportToCSV()
  95       self.maTableGroupes.exportToCSV()
  96       self.maTablePerfs.exportToCSV()
  97       self.maTableRatios.exportToCSV()
  98       self.maTableGroupeRatios.exportToCSV()
  99       self.maTableGroupeTailles.exportToCSV()
 100       if partiel==True: return
 101       self.maTableMailleurs.exportToCSV()
 102       self.maTableVersions.exportToCSV()
 103       self.maTableMaillages.exportToCSV()
 104       self.maTableMachines.exportToCSV()
 105       self.maTableGroupesRef.exportToCSV()
 106
 107   def importFromCSV(self,folder,partiel,force):
 108       if partiel==False:
 109          self.maTableMailleurs.importFromCSV(folder,force)
 110          self.maTableVersions.importFromCSV(folder,force)
 111          self.maTableMaillages.importFromCSV(folder,force)
 112          self.maTableGroupesRef.importFromCSV(folder,force)
 113          self.maTableMachines.importFromCSV(folder,force)
 114       self.maTableMailles.importFromCSV(folder,force)
 115       self.maTableGroupes.importFromCSV(folder,force)
 116       self.maTablePerfs.importFromCSV(folder,force)
 117       self.maTableRatios.importFromCSV(folder,force)
 118       self.maTableGroupesRef.importFromCSV(folder,force)
 119       self.maTableGroupeRatios.importFromCSV(folder,force)
 120       self.maTableGroupeTailles.importFromCSV(folder,force)
 121
 122   def Structure(self):
 123       # jamais appelee. juste pour memoire
 124       texteQuery='select * from sqlite_master;'
 125       maQuery=QSqlQuery()
 126       return maQuery.exec_(texteQuery)
 127
 128   def passeJobs(self,all,salomePath,version,force,listeMaillage):
 129       if all==True: paramMaillage=self.maTableMaillages.construitListeMaillages()
 130       else        : paramMaillage=self.maTableMaillages.verifieListeMaillages(listeMaillage)
 131       # paramMaillage=(( id, script, fichier med),)
 132
 133       bOk,versionId,versionName = self.maTableVersions.chercheVersion(version)
 134       if bOk==False:
 135          self.maTableVersions.creeVersion(version)
 136          print("nouvelle Version enregistree dans la base")
 137          bOk,versionId,versionName = self.maTableVersions.chercheVersion(version)
 138          if bOk==False:
 139             print("Impossible de creer la version")
 140             return
 141
 142       bOk,nomMachine = self.maTableMachines.chercheMachine()
 143       if bOk==False:
 144          self.maTableMachines.creeMachine()
 145          print("enregistrement de la machine dans la table des machines")
 146          bOk,nomMachine = self.maTableMachines.chercheMachine()
 147          if bOk==False:
 148             print("Impossible de creer la version")
 149             return
 150
 151
 152       for params in paramMaillage:
 153
 154          print("___________________________________________")
 155          print("")
 156          print(" Job : ", params[1])
 157          print(" Version de salome : ", versionName)
 158
 159
 160          idJob=params[0]
 161          mesGroupesRef=self.maTableGroupesRef.getVals(idJob)
 162          fichierGroupesRef=str(params[2]).replace('.med','_groupesRef.res')
 163          from Stats.utiles import writeFile
 164          if mesGroupesRef != [] :
 165            writeFile(fichierGroupesRef,",".join(mesGroupesRef))
 166          monjob=Job(params,salomePath,versionId,mesGroupesRef)
 167          print("")
 168          print("  Debut d execution")
 169          monjob.execute()
 170
 171          # remplit Perfs
 172          self.maTablePerfs.insereOuRemplaceLigne((idJob,versionId,nomMachine,int(monjob.getCPU()),0),False)
 173
 174          # remplit la table Mailles
 175          listeColonnes,listeValues=monjob.getStatSurMailles()
 176          i=0
 177          for col in listeColonnes :
 178             lVal=[idJob,versionId,col]+[listeValues[i]]
 179             lVal=tuple(lVal)
 180             if str(listeValues[i]) != str(0): self.maTableMailles.insereOuRemplaceLigne(lVal,False)
 181             i+=1
 182
 183          # remplit la table Tailles
 184          listeValues=monjob.getStatSurTailles()
 185          lVal=[params[0],versionId]+listeValues
 186          self.maTableTailles.insereOuRemplaceLigne(tuple(lVal),False)
 187
 188          # remplit la table Ratio
 189          maDim=self.maTableMaillages.getVal(params[0],'dimension')
 190          listeValues=monjob.getStatSurRatios()
 191          lVal=[params[0],versionId]+listeValues
 192          self.maTableRatios.insereOuRemplaceLigne(tuple(lVal),False)
 193
 194          # remplit les Groupes
 195          for groupe in mesGroupesRef:
 196              listeColonnes,listeValues=monjob.getStatSurGroupes(groupe)
 197              i=0
 198              for col in listeColonnes :
 199                 lVal=[groupe,params[0],versionId,col]+[listeValues[i]]
 200                 lVal=tuple(lVal)
 201                 if str(listeValues[i]) != str(0): self.maTableGroupes.insereOuRemplaceLigne(lVal,False)
 202                 i=i+1
 203
 204          # remplit les Ratio Groupes
 205          for groupe in mesGroupesRef:
 206              listeValues=monjob.getStatSurRatiosGroupes(groupe)
 207              if listeValues==['0','0','0','0','0','0'] : continue
 208              lVal=[params[0],versionId,groupe]+listeValues
 209              self.maTableGroupeRatios.insereOuRemplaceLigne(tuple(lVal),False)
 210              listeValues=monjob.getStatSurTaillesGroupes(groupe)
 211              lVal=[params[0],versionId,groupe]+listeValues
 212              self.maTableGroupeTailles.insereOuRemplaceLigne(tuple(lVal),False)
 213          monjob.menage()
 214
 215
 216
 217   def compare(self,version,ListeVersionRefString,fichier):
 218       print("_________________________________________________________________")
 219       print("Generation du rapport de comparaison")
 220       print(version)
 221       bOk,versionId,versionName = self.maTableVersions.chercheVersion(version)
 222       if bOk==False :
 223          print("version ", version , " inconnue dans la base")
 224          exit()
 225       print("Version a comparer : ", versionName)
 226       versionCompName=versionName
 227       versionCompId=versionId
 228
 229       listeVersionRefId=[]
 230       listeVersionRefName=[]
 231       ListeVersionRef=ListeVersionRefString.split(",")
 232       for id in ListeVersionRef:
 233           bOk,versionId,versionName = self.maTableVersions.chercheVersion(id)
 234           if bOk==False :
 235              print("version ", id , " inconnue dans la base")
 236              exit()
 237           listeVersionRefId.append(versionId)
 238           listeVersionRefName.append(versionName)
 239
 240       bOk,nomMachine = self.maTableMachines.chercheMachine()
 241       monDocument=Document()
 242       monDocument.initEntete(versionCompName, nomMachine)
 243
 244       maillagesIdListe, maillagesNameListe=self.maTableMaillages.getTous()
 245       if len(maillagesIdListe) != len (listeVersionRefId):
 246          print("Pas assez de version de reference")
 247          exit()
 248
 249       allEntitySurMaille=self.maTableMailles.getAllEntity()
 250       allEntitySurGroupe=self.maTableGroupes.getAllEntity()
 251
 252       # Boucle sur les maillages
 253       for idMaillage in maillagesIdListe :
 254           print(idMaillage)
 255           versionRefId=listeVersionRefId[idMaillage - 1]
 256           versionRefName=listeVersionRefName[idMaillage - 1]
 257           mailleurId=self.maTableMaillages.getMailleurId(idMaillage)
 258           mailleurName=self.maTableMailleurs.getName(mailleurId)
 259
 260           # Recuperation des seuils
 261           l1,l2,l3,l4,l5,l6=self.maTableMaillages.getSeuilsPourMaillage(idMaillage)
 262           monSeuilCPU=l3
 263           monSeuilRatio=l4
 264           monSeuilTaille=l5
 265           monSeuilNbMaille=l6
 266
 267
 268           # Et du temps CPU
 269           dicoMaillage={}
 270           dicoMaillage["NBCPU"]=self.maTablePerfs.getVal(idMaillage,versionCompId,nomMachine)
 271           dicoMaillage["REFCPU"]=self.maTablePerfs.getVal(idMaillage,versionRefId,nomMachine)
 272           dicoMaillage["DIFCPU"],dicoMaillage["DIFREL"],dicoMaillage["WARNING"]=self.calculDiffCPU(dicoMaillage["NBCPU"],dicoMaillage["REFCPU"],monSeuilCPU)
 273           monDocument.initMaillage(maillagesNameListe[idMaillage-1],mailleurName,versionRefName,dicoMaillage)
 274
 275           # Boucle sur les Mailles
 276
 277           dico={}
 278           dico["TITRE"]="Nombre de Mailles dans le maillage entier"
 279           i=0
 280           for nomColonne in allEntitySurMaille:
 281                  val=self.maTableMailles.getVal(idMaillage,versionCompId,nomColonne)
 282                  valRef=self.maTableMailles.getVal(idMaillage,versionRefId,nomColonne)
 283                  if val==0 and valRef==0 : continue
 284                  i=i+1
 285                  #print nomColonne;print val; print valRef
 286                  cMAIL="MAIL"+str(i); cREF="REF"+str(i)
 287                  cNB="NB"+str(i); cDIF="DIF"+str(i); cREL="REL"+str(i)
 288                  cWARN="WARN"+str(i);
 289                  dico[cMAIL]=nomColonne
 290                  dico[cREF]=valRef
 291                  dico[cNB]=val
 292                  dico[cDIF],dico[cREL],dico[cWARN]=self.calculDiff(val,valRef,monSeuilNbMaille)
 293           monDocument.initMaille(dico,i)
 294
 295
 296
 297           #
 298           dicoMaillage={}
 299
 300           dicoMaillage["RMAX"]=self.maTableRatios.getVal(idMaillage,versionCompId,'RatioMax')
 301           dicoMaillage["RMAXREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'RatioMax')
 302           dicoMaillage["DIFARMAX"],dicoMaillage["DIFRRMAX"],dicoMaillage["WRRMAX"]=self.calculDiff(dicoMaillage["RMAX"],dicoMaillage["RMAXREF"],monSeuilRatio)
 303           dicoMaillage["RMIN"]=self.maTableRatios.getVal(idMaillage,versionCompId,'RatioMin')
 304           dicoMaillage["RMINREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'RatioMin')
 305           dicoMaillage["DIFARMIN"],dicoMaillage["DIFRRMIN"],dicoMaillage["WRRMIN"]=self.calculDiff(dicoMaillage["RMIN"],dicoMaillage["RMINREF"],monSeuilRatio)
 306           dicoMaillage["RMOY"]=self.maTableRatios.getVal(idMaillage,versionCompId,'Moyenne')
 307           dicoMaillage["RMOYREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'Moyenne')
 308           dicoMaillage["DIFARMOY"],dicoMaillage["DIFRRMOY"],dicoMaillage["WRRMOY"]=self.calculDiff(dicoMaillage["RMOY"],dicoMaillage["RMOYREF"],monSeuilRatio)
 309           dicoMaillage["R1Q"]=self.maTableRatios.getVal(idMaillage,versionCompId,'Q1')
 310           dicoMaillage["R1QREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'Q1')
 311           dicoMaillage["DIFAR1Q"],dicoMaillage["DIFRR1Q"],dicoMaillage["WRR1Q"]=self.calculDiff(dicoMaillage["R1Q"],dicoMaillage["R1QREF"],monSeuilRatio)
 312           dicoMaillage["RMED"]=self.maTableRatios.getVal(idMaillage,versionCompId,'Mediane')
 313           dicoMaillage["RMEDREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'Mediane')
 314           dicoMaillage["DIFARMED"],dicoMaillage["DIFRRMED"],dicoMaillage["WRRMED"]=self.calculDiff(dicoMaillage["RMED"],dicoMaillage["RMEDREF"],monSeuilRatio)
 315           dicoMaillage["R3Q"]=self.maTableRatios.getVal(idMaillage,versionCompId,'Q3')
 316           dicoMaillage["R3QREF"]=self.maTableRatios.getVal(idMaillage,versionRefId,'Q3')
 317           dicoMaillage["DIFAR3Q"],dicoMaillage["DIFRR3Q"],dicoMaillage["WRR3Q"]=self.calculDiff(dicoMaillage["R3Q"],dicoMaillage["R3QREF"],monSeuilRatio)
 318
 319           dicoMaillage["TMAX"]=self.maTableTailles.getVal(idMaillage,versionCompId,'TailleMax')
 320           dicoMaillage["TMAXREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'TailleMax')
 321           dicoMaillage["DIFATMAX"],dicoMaillage["DIFRTMAX"],dicoMaillage["WTMAX"]=self.calculDiff(dicoMaillage["TMAX"],dicoMaillage["TMAXREF"],monSeuilTaille)
 322           dicoMaillage["TMIN"]=self.maTableTailles.getVal(idMaillage,versionCompId,'TailleMin')
 323           dicoMaillage["TMINREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'TailleMin')
 324           dicoMaillage["DIFATMIN"],dicoMaillage["DIFRTMIN"],dicoMaillage["WTMIN"]=self.calculDiff(dicoMaillage["TMIN"],dicoMaillage["TMINREF"],monSeuilTaille)
 325           dicoMaillage["TMOY"]=self.maTableTailles.getVal(idMaillage,versionCompId,'Moyenne')
 326           dicoMaillage["TMOYREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'Moyenne')
 327           dicoMaillage["DIFATMOY"],dicoMaillage["DIFRTMOY"],dicoMaillage["WTMOY"]=self.calculDiff(dicoMaillage["TMOY"],dicoMaillage["TMOYREF"],monSeuilTaille)
 328           dicoMaillage["T1Q"]=self.maTableTailles.getVal(idMaillage,versionCompId,'Q1')
 329           dicoMaillage["T1QREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'Q1')
 330           dicoMaillage["DIFAT1Q"],dicoMaillage["DIFRT1Q"],dicoMaillage["WT1Q"]=self.calculDiff(dicoMaillage["T1Q"],dicoMaillage["T1QREF"],monSeuilTaille)
 331           dicoMaillage["TMED"]=self.maTableTailles.getVal(idMaillage,versionCompId,'Mediane')
 332           dicoMaillage["TMEDREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'Mediane')
 333           dicoMaillage["DIFATMED"],dicoMaillage["DIFRTMED"],dicoMaillage["WTMED"]=self.calculDiffCPU(dicoMaillage["TMED"],dicoMaillage["TMEDREF"],monSeuilTaille)
 334           dicoMaillage["T3Q"]=self.maTableTailles.getVal(idMaillage,versionCompId,'Q3')
 335           dicoMaillage["T3QREF"]=self.maTableTailles.getVal(idMaillage,versionRefId,'Q3')
 336           dicoMaillage["DIFAT3Q"],dicoMaillage["DIFRT3Q"],dicoMaillage["WT3Q"]=self.calculDiffCPU(dicoMaillage["T3Q"],dicoMaillage["T3QREF"],monSeuilTaille)
 337
 338           #PNPNPN a revoir le initJob
 339           monDocument.initJob(dicoMaillage)
 340
 341
 342           # Boucle sur les groupes du maillage
 343           mesGroupesRef=self.maTableGroupesRef.getVals(idMaillage)
 344           if mesGroupesRef==[] : monDocument.addNoGroup()
 345           for groupeId in mesGroupesRef:
 346               i=0
 347               dico={}
 348               dico["TITRE"]="Nombre de Mailles dans le groupe "+groupeId
 349               for nomColonne in allEntitySurGroupe:
 350                   val=self.maTableGroupes.getVal(groupeId,idMaillage,versionCompId,nomColonne)
 351                   valRef=self.maTableGroupes.getVal(groupeId,idMaillage,versionRefId,nomColonne)
 352                   if val==0 and valRef==0 : continue
 353                   i=i+1
 354                   cMAIL="MAIL"+str(i); cREF="REF"+str(i)
 355                   cNB="NB"+str(i); cDIF="DIF"+str(i); cREL="REL"+str(i)
 356                   cWARN="WARN"+str(i);
 357                   dico[cMAIL]=nomColonne
 358                   dico[cREF]=valRef
 359                   dico[cNB]=val
 360                   dico[cDIF],dico[cREL],dico[cWARN]=self.calculDiff(val,valRef,monSeuilNbMaille)
 361                   monDocument.initMaille(dico,i)
 362
 363
 364               #
 365               dico={}
 366
 367               if self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'RatioMax') != 0 :
 368                  dico["RMAX"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'RatioMax')
 369                  dico["RMAXREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'RatioMax')
 370                  dico["DIFARMAX"],dico["DIFRRMAX"],dico["WRRMAX"]=self.calculDiff(dico["RMAX"],dico["RMAXREF"],monSeuilRatio)
 371                  dico["RMIN"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'RatioMin')
 372                  dico["RMINREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'RatioMin')
 373                  dico["DIFARMIN"],dico["DIFRRMIN"],dico["WRRMIN"]=self.calculDiff(dico["RMIN"],dico["RMINREF"],monSeuilRatio)
 374                  dico["RMOY"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'Moyenne')
 375                  dico["RMOYREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'Moyenne')
 376                  dico["DIFARMOY"],dico["DIFRRMOY"],dico["WRRMOY"]=self.calculDiff(dico["RMOY"],dico["RMOYREF"],monSeuilRatio)
 377                  dico["R1Q"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'Q1')
 378                  dico["R1QREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'Q1')
 379                  dico["DIFAR1Q"],dico["DIFRR1Q"],dico["WRR1Q"]=self.calculDiff(dico["R1Q"],dico["R1QREF"],monSeuilRatio)
 380                  dico["RMED"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'Mediane')
 381                  dico["RMEDREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'Mediane')
 382                  dico["DIFARMED"],dico["DIFRRMED"],dico["WRRMED"]=self.calculDiff(dico["RMED"],dico["RMEDREF"],monSeuilRatio)
 383                  dico["R3Q"]=self.maTableGroupeRatios.getVal(idMaillage,versionCompId,groupeId,'Q3')
 384                  dico["R3QREF"]=self.maTableGroupeRatios.getVal(idMaillage,versionRefId,groupeId,'Q3')
 385                  dico["DIFAR3Q"],dico["DIFRR3Q"],dico["WRR3Q"]=self.calculDiff(dico["R3Q"],dico["R3QREF"],monSeuilRatio)
 386                  monDocument.CreeGroupeRatios(dico)
 387
 388               dico={}
 389               if self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'TailleMax') != 0:
 390                  dico["TMAX"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'TailleMax')
 391                  dico["TMAXREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'TailleMax')
 392                  dico["DIFATMAX"],dico["DIFRTMAX"],dico["WTMAX"]=self.calculDiff(dico["TMAX"],dico["TMAXREF"],monSeuilTaille)
 393                  dico["TMIN"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'TailleMin')
 394                  dico["TMINREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'TailleMin')
 395                  dico["DIFATMIN"],dico["DIFRTMIN"],dico["WTMIN"]=self.calculDiff(dico["TMIN"],dico["TMINREF"],monSeuilTaille)
 396                  dico["TMOY"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'Moyenne')
 397                  dico["TMOYREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'Moyenne')
 398                  dico["DIFATMOY"],dico["DIFRTMOY"],dico["WTMOY"]=self.calculDiff(dico["TMOY"],dico["TMOYREF"],monSeuilTaille)
 399                  dico["T1Q"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'Q1')
 400                  dico["T1QREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'Q1')
 401                  dico["DIFAT1Q"],dico["DIFRT1Q"],dico["WT1Q"]=self.calculDiff(dico["T1Q"],dico["T1QREF"],monSeuilTaille)
 402                  dico["TMED"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'Mediane')
 403                  dico["TMEDREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'Mediane')
 404                  dico["DIFATMED"],dico["DIFRTMED"],dico["WTMED"]=self.calculDiffCPU(dico["TMED"],dico["TMEDREF"],monSeuilTaille)
 405                  dico["T3Q"]=self.maTableGroupeTailles.getVal(idMaillage,versionCompId,groupeId,'Q3')
 406                  dico["T3QREF"]=self.maTableGroupeTailles.getVal(idMaillage,versionRefId,groupeId,'Q3')
 407                  dico["DIFAT3Q"],dico["DIFRT3Q"],dico["WT3Q"]=self.calculDiffCPU(dico["T3Q"],dico["T3QREF"],monSeuilTaille)
 408                  monDocument.CreeGroupeTaille(dico)
 409
 410
 411
 412
 413
 414       monDocument.creeDocument(fichier)
 415
 416   def calculDiffCPU(self,nb,nbRef,seuil):
 417          # different de calculDiff : si on est inferieur a la reference
 418          # on n a pas de warning
 419          diff=nb-nbRef
 420          diffRel=((nb-nbRef)*100)/(nbRef*1.00)
 421          if diffRel > seuil :
 422             warning="plus de "+ str(seuil) + "% de difference CPU"
 423          else :
 424             warning=""
 425          diffRelStr=str(diffRel)+"%"
 426          return diff,diffRelStr,warning
 427
 428   def calculDiff(self,nb,nbRef,seuil):
 429          #print nb,nbRef,seuil
 430          diff=nb-nbRef
 431          diffRel=((nb-nbRef)*100)/(nbRef*1.00)
 432          if diffRel > seuil or (-1*diffRel) > seuil  :
 433             warning="difference superieure a "+ str(seuil) + "%"
 434          else :
 435             warning=""
 436          diffRelStr=str(diffRel)+"%"
 437          return diff,diffRelStr,warning
 438