VirtualPolymer/lienDB.py

   1 # coding: utf-8\r
   2 \r
   3 import types\r
   4 import sys,os\r
   5 \r
   6 import listesDB\r
   7 \r
   8 \r
   9 maClasseDelistesDB = listesDB.classeListesDB()\r
  10 monModele=listesDB.sModele().monModele\r
  11 monPost=listesDB.sModele().monPost\r
  12 \r
  13 import types\r
  14 class Tuple:\r
  15   def __init__(self,ntuple):\r
  16     self.ntuple=ntuple\r
  17 \r
  18   def __convert__(self,valeur):\r
  19     if type(valeur) == types.StringType:\r
  20       return None\r
  21     if len(valeur) != self.ntuple:\r
  22       return None\r
  23     return valeur\r
  24 \r
  25   def info(self):\r
  26     return "Tuple de %s elements" % self.ntuple\r
  27 \r
  28   __repr__=info\r
  29   __str__=info\r
  30 \r
  31 \r
  32 dicoAgingFactor={ '40years BR top' : {'temperature' : 50, 'simulationTime' : 350640}}\r
  33 \r
  34 # --------------------------------------\r
  35 # Fonctions appellees depuis le catalogue\r
  36 # --------------------------------------\r
  37  \r
  38 # --------------------------------------\r
  39 # Dans Equation\r
  40 # --------------------------------------\r
  41 \r
  42 def recupereDicoEquation(monMC):\r
  43     # Equation_reaction (ds 2 blocs)\r
  44     #  ou dans Equation b_type_show b_reaction_type\r
  45     #  ou dans Equation b_type_show b_aging_type\r
  46 \r
  47     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
  48     editor=monMC.jdc.editor\r
  49     monMC.dsMaFunct = True\r
  50 \r
  51     valeurDB=editor.getValeur('Equation','Equation_DB',())\r
  52     maClasseDelistesDB.metAJour(valeurDB)\r
  53     listEquation=maClasseDelistesDB.getListEquation()\r
  54 \r
  55     valeurEquationListe=editor.getValeur('Equation','Equation_Liste',('b_type_show',))\r
  56     valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_reaction_type',))\r
  57     if valeurAgingType == None :\r
  58        valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_aging_type',))\r
  59     if valeurAgingType == None : monMC.dsMaFunct = False; return\r
  60 \r
  61     listeEquationPourIhm = []\r
  62     listeReprEquationPourIhm = []\r
  63     dicoListAffiche = {}\r
  64    \r
  65     for equation in listEquation :\r
  66         if valeurEquationListe == 'aging_type' :\r
  67            if equation.type_vieil == valeurAgingType : \r
  68               listeEquationPourIhm.append(equation)\r
  69               listeReprEquationPourIhm.append(equation.representation)\r
  70               dicoListAffiche[equation.representation]=equation\r
  71         else:\r
  72            if equation.type_react == valeurAgingType : \r
  73               listeEquationPourIhm.append(equation)\r
  74               listeReprEquationPourIhm.append(equation.representation)\r
  75               dicoListAffiche[equation.representation]=equation\r
  76     maClasseDelistesDB.dicoListAffiche = dicoListAffiche\r
  77 \r
  78     change=editor.changeIntoDefMC('Equation', ('b_type_show','ListeEquation'), listeReprEquationPourIhm )\r
  79     if change :\r
  80        editor.reCalculeValiditeMCApresChgtInto('Equation', 'listeEquation', ('b_type_show',)) \r
  81        if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
  82     monMC.dsMaFunct = False\r
  83 \r
  84 def afficheValeurEquation(monMC):\r
  85     # Equation b_modification modification\r
  86     print (monMC)\r
  87     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
  88     valeur=monMC.valeur\r
  89     if valeur == None : return\r
  90     maClasseDelistesDB.valeurEquationChoisie=str(valeur)\r
  91     monEquation=maClasseDelistesDB.dicoListAffiche[str(valeur)]\r
  92 \r
  93     aAfficher=str(monEquation)\r
  94     editor=monMC.jdc.editor\r
  95     editor._viewText(aAfficher, "Id",largeur=80,hauteur=300)\r
  96     \r
  97     monMC.dsMaFunct = False\r
  98               \r
  99 \r
 100 def instancieChemicalFormulation(monMC):\r
 101     print ('instancieChemicalFormulation pour ', monMC.nom)\r
 102     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 103     if monMC.valeur == False : return\r
 104 \r
 105     editor=monMC.jdc.editor\r
 106     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 107     editor.dsMaFunct = True\r
 108 \r
 109     for e in monMC.jdc.etapes:\r
 110         if e.nom == 'Equation' :break\r
 111     print ('ds instancie')\r
 112     v=maClasseDelistesDB.valeurEquationChoisie\r
 113     monEquation=maClasseDelistesDB.dicoListAffiche[v]\r
 114     type_react=monEquation.type_react\r
 115     type_vieil=monEquation.type_vieil\r
 116 \r
 117     editor.changeIntoMCandSet('Equation', ('b_type_show','b_modification','b_modif','ChemicalFormulation'),( v,),v )\r
 118     print ("je passe la")\r
 119     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Reaction_Type'),type_react )\r
 120     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Aging_Type'), type_vieil )\r
 121 \r
 122     for index,valeurConstituant in enumerate(monEquation.constituants):\r
 123         valeurEquation=monEquation.equation[index] \r
 124         \r
 125         #PNPNPN --> decider des noms SVP ave un nom python\r
 126         monMcl1=('Constituant','TXM',{'statut':'o','defaut':valeurConstituant})\r
 127         monMcl2=('Differential_Equation','TXM',{'statut':'o','defaut':valeurEquation})\r
 128         listeMC=(monMcl1,monMcl2)\r
 129         editor.ajoutDefinitionMCFact ('Equation',('b_type_show','b_modification','b_modif',),valeurConstituant,listeMC,statut='f')\r
 130         #editor.ajoutMCFact (e,('b_type_show','b_modification','b_modif',),valeurConstituant)\r
 131         print (index,valeurConstituant,valeurEquation)\r
 132 \r
 133             #OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
 134             #    Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
 135             #    Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
 136 \r
 137     for index,valeurConstituant in enumerate(monEquation.const_cine_nom):\r
 138          valeurArrhe=monEquation.arrhenius[index] \r
 139          if valeurArrhe : valeurConstanteType='Arrhenius type'\r
 140          else           : valeurConstanteType='non Arrhenius type'\r
 141          monMcl1=('ConstanteName','TXM',{'statut':'o','defaut':valeurConstituant})\r
 142          monMcl2=('ConstanteType','TXM',{'statut':'o','defaut':valeurConstanteType,'into': ('Arrhenius type','non Arrhenius type') })\r
 143          listeMC=(monMcl1,monMcl2)\r
 144          editor.ajoutDefinitionMCFact ('Equation',('b_type_show','b_modification','b_modif',),valeurConstituant,listeMC,statut='f')\r
 145          #editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))\r
 146 \r
 147 \r
 148     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Commentaire'),monEquation.comment )\r
 149     print (monEquation.comment )\r
 150     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 151 \r
 152     monMC.dsMaFunct = False\r
 153     editor.dsMaFunct = False\r
 154  \r
 155 \r
 156 \r
 157 \r
 158 def recupereDicoModele(monMC):\r
 159     if monMC.valeur == None: return\r
 160     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 161     monMC.dsMaFunct = True\r
 162     print ('je passe dans recupereDicoModele')\r
 163 \r
 164     editor=monMC.jdc.editor\r
 165     valeurDB=editor.getValeur('Modele','Modele_DB',())\r
 166     maClasseDelistesDB.metAJour(valeurDB)\r
 167 \r
 168     print ('fin recupereDicoModele')\r
 169     monMC.dsMaFunct = False\r
 170 \r
 171 \r
 172 def creeListeEquation(monMC):\r
 173     if monMC.valeur == None: return\r
 174     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 175     editor=monMC.jdc.editor\r
 176     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 177     editor.dsMaFunct = True\r
 178     print ('debut de creeListeEquation')\r
 179 \r
 180     listeEquationsAAfficher=[]\r
 181     listeConstantesAAfficher=[]\r
 182     listeInitialEquations=[]\r
 183 \r
 184     listEquation=maClasseDelistesDB.getListEquation()\r
 185     for index,equation in enumerate( listEquation):\r
 186         if index in monModele.equa:\r
 187             listeEquationsAAfficher.append(equation.representation)\r
 188             listeConstantesAAfficher.append(equation.const_cine_nom)\r
 189             t=equation.representation+'\t\t\t\t    '+str(equation.const_cine_nom)\r
 190             listeInitialEquations.append(t)\r
 191 \r
 192     change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','Initial_Equation_List'),listeInitialEquations )\r
 193     maClasseDelistesDB.listeEquationsAAfficher = listeEquationsAAfficher\r
 194     maClasseDelistesDB.listeConstantesAAfficher = listeConstantesAAfficher\r
 195     monMC.dsMaFunct = False\r
 196     print ('fin de creeListeEquation')\r
 197 \r
 198     editor.dsMaFunct = False\r
 199 \r
 200   #        listeEquation_stabilization=SIMP(statut='o', homo='SansOrdreNiDoublon', max='**', min=0 ),\r
 201 \r
 202 def recupereModeleEquation(monMC):\r
 203     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 204     if monMC.valeur==False : return\r
 205     editor=monMC.jdc.editor\r
 206     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 207     editor.dsMaFunct = True\r
 208     print ('je suis dans  recupereModeleEquation')\r
 209 \r
 210     editor.dsMaFunct = True\r
 211     dicoListeEquationAAfficher={}\r
 212 \r
 213     from VP_Cata_V2 import monDico\r
 214     listEquation=maClasseDelistesDB.getListEquation()\r
 215     for valeurReactionType in monDico['Equation_Liste']:\r
 216       dicoListeEquationAAfficher[valeurReactionType] = [] \r
 217       for index,equation in enumerate( listEquation):\r
 218         if equation.type_react==valeurReactionType : \r
 219            dicoListeEquationAAfficher[valeurReactionType].append(equation.representation)\r
 220            maClasseDelistesDB.dictParametresInitiaux[equation.representation]=equation\r
 221     #print (dicoListeEquationAAfficher)\r
 222     #print('maClasseDelistesDB.dictParametresInitiaux', maClasseDelistesDB.dictParametresInitiaux)\r
 223     prepareDiffusionSansMC(editor,monMC.nom)\r
 224        \r
 225     change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_initiation'),dicoListeEquationAAfficher['initiation'])\r
 226     change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_propagation'),dicoListeEquationAAfficher['propagation'] )\r
 227     change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_termination'),dicoListeEquationAAfficher['termination'] )\r
 228     change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_stabilization'),dicoListeEquationAAfficher['stabilization'] )\r
 229     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 230 \r
 231     print ('fin recupereModeleEquation')\r
 232     monMC.dsMaFunct = False\r
 233     editor.dsMaFunct = False\r
 234 \r
 235 def ajoutDUneEquation(monMC):\r
 236     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 237     if monMC.valeur==False : return\r
 238     editor=monMC.jdc.editor\r
 239     prepareDiffusionSansMC(editor,monMC.nom)\r
 240     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 241     editor.dsMaFunct = False\r
 242     monMC.dsMaFunct = False\r
 243 \r
 244 def prepareDiffusion(monMC):\r
 245     if monMC.valeur==False : return\r
 246     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 247     monMC.dsMaFunct=True\r
 248     editor=monMC.jdc.editor\r
 249     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 250     editor.dsMaFunct = True\r
 251     print ('je suis dans prepareDiffusion', monMC.nom)\r
 252     prepareDiffusionSansMC(editor,monMC.nom)\r
 253     print ('fin de prepareDiffusion', monMC.nom)\r
 254     monMC.dsMaFunct=False\r
 255     editor.dsMaFunct = False\r
 256 \r
 257 def prepareDiffusionSansMC(editor,monMCNom):\r
 258     lInitialBadCoche=editor.getValeur('Modele', 'Initial_Equation_List',('b_type_creation','Chemical_Equation'),)\r
 259     lInitialCoche=[]\r
 260     for equ in lInitialBadCoche: lInitialCoche.append(equ.split('\t')[0])\r
 261     lInititiationCoche=editor.getValeur('Modele','listeEquation_initiation', ('b_type_creation','Chemical_Equation',))\r
 262     lPropagationCoche =editor.getValeur('Modele', 'listeEquation_propagation',('b_type_creation','Chemical_Equation',))\r
 263     lTerminationCoche=editor.getValeur('Modele','listeEquation_termination', ('b_type_creation','Chemical_Equation',))\r
 264     lStabilizationCoche=editor.getValeur('Modele','listeEquation_stabilization', ('b_type_creation','Chemical_Equation',))\r
 265 \r
 266     print (lInitialCoche,lInititiationCoche,lPropagationCoche,lTerminationCoche,lStabilizationCoche)\r
 267     for liste in (lInitialCoche,lInititiationCoche,lPropagationCoche,lTerminationCoche,lStabilizationCoche):\r
 268         # Il est possible qu'une liste soit vide lors de l initialisation\r
 269         if liste == None : continue \r
 270         for equation in liste :\r
 271             print (equation)\r
 272             for const in maClasseDelistesDB.dictParametresInitiaux[equation].constituants :\r
 273               if const not in maClasseDelistesDB.listeParametresInitiaux : maClasseDelistesDB.listeParametresInitiaux.append(const)\r
 274             #for coef in maClasseDelistesDB.dictParametresInitiaux[equation].const_cine_nom :\r
 275             #  if coef not in maClasseDelistesDB.listeCoefInitiaux : maClasseDelistesDB.listeCoefInitiaux.append(coef)\r
 276             for num,coef in enumerate(maClasseDelistesDB.dictParametresInitiaux[equation].const_cine_nom ):\r
 277               maClasseDelistesDB.dicoCoefAffichageArr[coef]=maClasseDelistesDB.dictParametresInitiaux[equation].arrhenius[num]\r
 278               if coef not in maClasseDelistesDB.listeCoefInitiaux : maClasseDelistesDB.listeCoefInitiaux.append(coef)\r
 279 \r
 280     #print('maClasseDelistesDB.dictParametresInitiaux', maClasseDelistesDB.dictParametresInitiaux)\r
 281     if monMCNom == 'Diffusion' :\r
 282        change=editor.changeIntoDefMC('Modele', ('b_type_creation','Transport','b_diffusion','listeProduitPourLaDiffusion'), maClasseDelistesDB.listeParametresInitiaux )\r
 283     if monMCNom == 'Evaporation' :\r
 284        change=editor.changeIntoDefMC('Modele', ('b_type_creation','Transport','b_evaporation','listeProduitPourLEvaporation'), maClasseDelistesDB.listeParametresInitiaux )\r
 285 \r
 286     if monMCNom in ('Evaporation','Diffusion') :\r
 287        for c in list(monModele.coef[0].keys()) :\r
 288         if c[0]=='D':\r
 289            clef=c[1:]\r
 290            if clef in maClasseDelistesDB.listeParametresInitiaux :\r
 291               maClasseDelistesDB.listeCoefD.append(clef)\r
 292               maClasseDelistesDB.listeCoefInitiaux.append('D'+clef)\r
 293               maClasseDelistesDB.listeCoefInitiaux.append('S'+clef)\r
 294            else :\r
 295               maClasseDelistesDB.listeCoefASupprimer.append('S'+clef)\r
 296               maClasseDelistesDB.listeCoefASupprimer.append('D'+clef)\r
 297         if c[0]=='B':\r
 298            clef=c[1:]\r
 299            if clef in maClasseDelistesDB.listeParametresInitiaux :\r
 300               maClasseDelistesDB.listeCoefB.append(clef)\r
 301               maClasseDelistesDB.listeCoefInitiaux.append(c)\r
 302            else :\r
 303               maClasseDelistesDB.listeCoefASupprimer.append(c)\r
 304     print ('aClasseDelistesDB.listeCoefB',maClasseDelistesDB.listeCoefB)\r
 305     print ('aClasseDelistesDB.listeCoefB',maClasseDelistesDB.listeCoefD)\r
 306     print ('maClasseDelistesDB.listeCoefInitiaux',maClasseDelistesDB.listeCoefInitiaux)\r
 307     print ('maClasseDelistesDB.listeCoefASupprimer',maClasseDelistesDB.listeCoefASupprimer)\r
 308     print ('maClasseDelistesDB.listeParametresInitiaux',maClasseDelistesDB.listeParametresInitiaux)\r
 309     # au lieu des print il faut mettre a jour le MC Fact Coefficients avec ,maClasseDelistesDB.listeCoefInitiaux et le MC FACT\r
 310     # Paraetres_initiaux avec maClasseDelistesDB.listeParametresInitiaux\r
 311     # TO DO TO DO PNPN\r
 312     # si on arrive avex\r
 313     # if monMC.nom = Diffusion \r
 314     if monMCNom == 'Diffusion' :\r
 315       editor.setValeur('Modele','listeProduitPourLaDiffusion' ,maClasseDelistesDB.listeCoefD, ('b_type_creation','Transport','b_diffusion',))\r
 316     #editor.changeValeur(....,'listeProduitPourLaDiffusion',maClasseDelistesDB.listeCoefD')\r
 317     # if monMCNom == 'Evaporation' :\r
 318     #editor.changeValeur(....,'listeProduitPourLaDiffusion',maClasseDelistesDB.listeCoefB')\r
 319 \r
 320 \r
 321 \r
 322 def ajouteEvaporation(monMC):\r
 323     print ('je suis dans ajouteDiffusion')\r
 324     if monMC.valeur == None : return\r
 325     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 326     editor=monMC.jdc.editor\r
 327     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 328 \r
 329     monMC.dsMaFunct=True\r
 330     for v in monMC.valeur :\r
 331         clef='B'+v\r
 332         if clef not in maClasseDelistesDB.listeCoefInitiaux :\r
 333               maClasseDelistesDB.listeCoefInitiaux.append(clef)\r
 334 \r
 335     print ('sortie de ajouteDiffusion' , maClasseDelistesDB.listeCoefInitiaux)\r
 336     monMC.dsMaFunct=False\r
 337     editor.dsMaFunct = False\r
 338 \r
 339 def ajouteDiffusion(monMC):\r
 340     print ('je suis dans ajouteDiffusion')\r
 341     if monMC.valeur == None : return\r
 342     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 343     editor=monMC.jdc.editor\r
 344     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 345 \r
 346     monMC.dsMaFunct=True\r
 347     for v in monMC.valeur :\r
 348         clef='D'+v\r
 349         if clef not in maClasseDelistesDB.listeCoefInitiaux :\r
 350               maClasseDelistesDB.listeCoefInitiaux.append(clef)\r
 351               maClasseDelistesDB.listeCoefInitiaux.append('S'+v)\r
 352               maClasseDelistesDB.dicoCoefAffichageArr[clef] = True\r
 353               maClasseDelistesDB.dicoCoefAffichageArr['S'+v] = False\r
 354               #maClasseDelistesDB.dicoCoefAffichageArr['B'+v] = True\r
 355         \r
 356         # on affiche dans l interface  un mot clef avec clef comme nom et \r
 357         # 2 reels si ce commence par D soit iniitialise a 0 si pas de valeur\r
 358         # soit avec comme deifaut nomCoef in monModele.coef[0].keys()\r
 359     print ('sortie de ajouteDiffusion' , maClasseDelistesDB.listeCoefInitiaux)\r
 360 \r
 361     for nomCoef in maClasseDelistesDB.listeCoefInitiaux:\r
 362         #A jout Ds Coef d'un MC \r
 363         nomMC='Coef_'+nomCoef \r
 364         if maClasseDelistesDB.dicoCoefAffichageArr[nomCoef]  == True:\r
 365            print ('2 r'), \r
 366            if nomCoef in monModele.coef[0].keys() :\r
 367               print (monModele.coef[0][nomCoef])\r
 368            else :\r
 369               print ((0,0))\r
 370         else :\r
 371            print ('1 r') \r
 372            if nomCoef in monModele.coef[0].keys() :\r
 373               print (monModele.coef[0][nomCoef])\r
 374            else :\r
 375               print (0)\r
 376 \r
 377     print ('______________________')\r
 378     #for v in monMC.valeur :\r
 379     #    print (v)\r
 380     #    mesValeurs=editor.dicoCoefS[v]\r
 381     #    MCFils='S'+v\r
 382     #    for e in monMC.jdc.etapes:\r
 383     #        if e.nom == 'Modele' :break\r
 384     #    editor.ajoutDefinitionMC(e,('b_type_creation','b_diffusion'),MCFils,typ='TXM',statut='o' )\r
 385     #    editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))\r
 386     #    print ('______')\r
 387     #if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 388     monMC.dsMaFunct=False\r
 389     editor.dsMaFunct = False\r
 390 \r
 391 \r
 392 # --------------------------------------------------------------------------------------------\r
 393 # pour les modeles en modification ou en utilisation\r
 394 # --------------------------------------------------------------------------------------------\r
 395 def creeListeMateriauxSelonModele(monMC):\r
 396     if monMC.valeur == None : return\r
 397     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 398     editor=monMC.jdc.editor\r
 399     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 400 \r
 401     valeurDB=editor.getValeur('Modele','Modele_DB',())\r
 402     maClasseDelistesDB.metAJour(valeurDB)\r
 403     listModele=maClasseDelistesDB.getListModele()\r
 404     listModeleFiltre=[]\r
 405     listMateriauxFiltre=[]\r
 406     for modele in listModele :\r
 407         if modele.technical_use == monMC.valeur :\r
 408            maClasseDelistesDB.dicoModeleFiltre[modele.nom]=modele\r
 409            listModeleFiltre.append(modele.nom)\r
 410            if type(modele.materiaux) not in (list, tuple): modeleATraiter= modele.materiaux\r
 411            else : modeleATraiter= modele.materiaux[0]\r
 412            if modeleATraiter not in listMateriauxFiltre :\r
 413               listMateriauxFiltre.append(modeleATraiter)\r
 414               maClasseDelistesDB.dicoMateriauxFiltre[modeleATraiter]=[modele.nom,]\r
 415            else :\r
 416               maClasseDelistesDB.dicoMateriauxFiltre[modeleATraiter].append(modele.nom)\r
 417  \r
 418            \r
 419 \r
 420     change=editor.changeIntoDefMC('Modele', ('b_type_modification','b_technicalUse','material'),listMateriauxFiltre )\r
 421 \r
 422     monMC.dsMaFunct=False\r
 423     editor.dsMaFunct = False\r
 424 \r
 425 def creeListeModelesPossibles(monMC):\r
 426     if monMC.valeur == None : return\r
 427     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 428     editor=monMC.jdc.editor\r
 429     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 430     change=editor.changeIntoDefMC('Modele', ('b_type_modification','b_technicalUse','modele'),maClasseDelistesDB.dicoMateriauxFiltre[monMC.valeur] )\r
 431 \r
 432     monMC.dsMaFunct=False\r
 433     editor.dsMaFunct = False\r
 434 \r
 435 def choisitModele(monMC):\r
 436     # Equation b_modification modification\r
 437     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 438     valeur=monMC.valeur\r
 439     if valeur == None : return\r
 440     modele=maClasseDelistesDB.dicoModeleFiltre[monMC.valeur]\r
 441     maClasseDelistesDB.monModele=modele\r
 442     monMC.dsMaFunct = False\r
 443 \r
 444 def choisitActionModele(monMC):\r
 445     if monMC.valeur == 'display' : afficheModele(monMC)\r
 446     if monMC.valeur == 'modify' : changeValeurDefautModele(monMC)\r
 447 \r
 448 def afficheModele(monMC):\r
 449     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 450     valeur=monMC.valeur\r
 451     aAfficher=str(maClasseDelistesDB.monModele)\r
 452     editor=monMC.jdc.editor\r
 453     editor._viewText(aAfficher, "Id",largeur=700,hauteur=500)\r
 454     \r
 455     monMC.dsMaFunct = False\r
 456               \r
 457 def changeValeurDefautModele(monMC):\r
 458     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 459     monMC.dsMaFunct = True\r
 460     editor=monMC.jdc.editor\r
 461     change=editor.changeIntoMCandSet('Modele', ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID','modeleName'),(maClasseDelistesDB.monModele.nom,),maClasseDelistesDB.monModele.nom, )\r
 462     editor.setValeur('Modele','technicalUse',maClasseDelistesDB.monModele.technical_use, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 463 \r
 464     editor.setValeur('Modele','material',maClasseDelistesDB.monModele.materiaux, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 465     editor.setValeur('Modele','agingType',maClasseDelistesDB.monModele.type_vieil, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 466 \r
 467     if maClasseDelistesDB.monModele.stabilise == 'True' : monBool = True\r
 468     else : monBool = False\r
 469     editor.setValeur('Modele','stabilizer',monBool, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 470     editor.setValeur('Modele','material_thickness',maClasseDelistesDB.monModele.thickness, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 471 \r
 472     if maClasseDelistesDB.monModele.dvt_EDF == 'True' : monBool = True\r
 473     else : monBool = False\r
 474     editor.setValeur('Modele','model_developed_by_for_EDF',monBool, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 475     editor.setValeur('Modele','documentation',maClasseDelistesDB.monModele.reference, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
 476     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 477     monMC.dsMaFunct = False\r
 478 \r
 479 \r
 480 \r
 481 def creeCoefAModifier(monMC):\r
 482     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 483     if monMC.valeur == None : return\r
 484     monMC.dsMaFunct = True\r
 485     editor=monMC.jdc.editor\r
 486     dicoArr={}\r
 487     dicoNonArr={}\r
 488     for coef in maClasseDelistesDB.monModele.coef[0] :\r
 489         if len (maClasseDelistesDB.monModele.coef[0][coef]) == 1 :\r
 490                dicoNonArr[coef]=maClasseDelistesDB.monModele.coef[0][coef][0]\r
 491         else :\r
 492                dicoArr[coef]=maClasseDelistesDB.monModele.coef[0][coef]\r
 493                if coef[0] == 'D' : maClasseDelistesDB.listeDiffusion.append(coef[1:])\r
 494     print (dicoNonArr)\r
 495     print (dicoArr)\r
 496     if 'ri' in dicoNonArr :\r
 497        print ('ajoutDefinitionMC debitOfDose')\r
 498        editor.ajoutDefinitionMC('Modele', ('b_type_modification','b_technicalUse','b_modele','b_type_use2','Aging_Factor'), 'debitOfDose',typ='R',statut='o' )\r
 499 \r
 500     for coef in dicoNonArr :\r
 501         print (coef)\r
 502         # attention, notation scientifique\r
 503         editor.ajoutDefinitionMC('Modele',('b_type_modification','b_technicalUse','b_modele','b_type_use',),coef, 'R', statut='o',defaut=dicoNonArr[coef])\r
 504         # a faire marcher\r
 505         # pour les Arr il faut un tuple(2)\r
 506        \r
 507     # il fait creer un fact Boundary_Conditions_Param pour chacque espece de listeDiffusion\r
 508    \r
 509     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 510 \r
 511     monMC.dsMaFunct = False\r
 512 \r
 513 \r
 514 def remplirAgingFactor(monMC):\r
 515     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 516     if monMC.valeur == None : return\r
 517     monMC.dsMaFunct = True\r
 518     editor=monMC.jdc.editor\r
 519     if monMC.valeur in dicoAgingFactor:\r
 520        print (monMC.valeur, 'trouve')\r
 521        for MC in dicoAgingFactor[monMC.valeur]:\r
 522            print (MC)\r
 523            print (dicoAgingFactor[monMC.valeur][MC]),\r
 524            editor.setValeur('Modele',MC,dicoAgingFactor[monMC.valeur][MC],('b_type_modification','b_technicalUse','b_modele','b_type_use2','Aging_Factor'))\r
 525     monMC.dsMaFunct = False\r
 526 \r
 527 \r
 528 def creeInitialParameter(monMC):\r
 529     print ('je passe dans creeInitialParameter')\r
 530     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 531     if monMC.valeur == None : return\r
 532     monMC.dsMaFunct = True\r
 533     editor=monMC.jdc.editor\r
 534     for coef in maClasseDelistesDB.monModele.param_ini:\r
 535         editor.ajoutDefinitionMC('Modele',('b_type_modification','b_technicalUse','b_modele','b_type_use2','Initial_Parameter'),coef, 'R', statut='o',defaut=maClasseDelistesDB.monModele.param_ini[coef][0])\r
 536     monMC.dsMaFunct = False\r
 537     # creer nbdenode = monMC.valeur Initial_Parameter\r