VirtualPolymer/VP_Cata_V1.py

   1 # coding: utf-8\r
   2 import types\r
   3 from Accas import *\r
   4 import sys,os\r
   5 sys.path.append('/home/A96028/opt/MAP/map-2016.1/lib/python2.7/site-packages/mapy/components/c_pre_polymer_data_management')\r
   6 sys.path.append('/home/A96028/opt/MAP/map-2016.1/lib/python2.7/site-packages/mapy/virtual_polymer_common')\r
   7 sys.path.append('/home/A96028/opt/MAP/map-2016.1/lib/python2.7/site-packages/')\r
   8 import pckdb, class_data, instruction, equation_part, utils\r
   9 \r
  10 \r
  11 monDico= { 'Equation_Liste' : ('initiation', 'propagation', 'termination', 'stabilization'),\r
  12            'Modele_TechnicalUse' : ('cable', 'coating', 'pipes'),\r
  13          }\r
  14 \r
  15 class Tuple:\r
  16   def __init__(self,ntuple):\r
  17     self.ntuple=ntuple\r
  18 \r
  19   def __convert__(self,valeur):\r
  20     if type(valeur) == types.StringType: return None\r
  21     if len(valeur) != self.ntuple: return None\r
  22     return valeur\r
  23 \r
  24   def info(self):\r
  25     return "Tuple de %s elements" % self.ntuple\r
  26 \r
  27   __repr__=info\r
  28   __str__=info\r
  29 \r
  30 #class ObjetUtilisateur(ASSD): pass\r
  31 \r
  32 class classeVisuEquation :\r
  33    def __init__(self,dicoListeAffiche, listEquation, listModele,listPostTraitement):\r
  34       self.dicoListeAffiche=dicoListeAffiche\r
  35       self.listEquation=listEquation\r
  36       self.listModele=listModele\r
  37       self.listPostTraitement=listPostTraitement\r
  38    \r
  39 \r
  40 def maFunc():\r
  41     return ('a1','a2','a3')\r
  42      \r
  43 def maFuncWithArg(monMC):\r
  44     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
  45     monMC.dsMaFunct = True\r
  46 \r
  47     editor=monMC.jdc.editor\r
  48     if monMC.valeur == 'POOH->P' : monInto=('a1','a2','a3')\r
  49     else : monInto=('b1','b2','b3')\r
  50 \r
  51     change=editor.changeIntoDefMC('AGING', ('Equation', 'b_approved','b_type_creation','Equation_Modification','Type2'), monInto )\r
  52     if change :\r
  53        print ('j ai change le into')\r
  54        editor.reCalculeValiditeMCApresChgtInto('AGING', 'Type2', ('Equation', 'b_approved','b_type_creation','Equation_Modification')) \r
  55        if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
  56 \r
  57     monMC.dsMaFunct = False\r
  58 \r
  59 def recupereDicoGenerique(monMC):\r
  60     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
  61     print ('je passe dans la recuperation')\r
  62     editor=monMC.jdc.editor\r
  63     valeurDB=editor.getValeur('Equation','Equation_DB',())\r
  64     if valeurDB == None : valeurDB=editor.getValeur('Modele','Modele_DB',())\r
  65     correspond=pckdb.DBRENAME\r
  66     if valeurDB != None :\r
  67        listEquation, listModele,listPostTraitement=pckdb.read_pckdb(correspond[valeurDB])\r
  68     monMC.dsMaFunct = False\r
  69     return listEquation, listModele,listPostTraitement\r
  70 \r
  71 def recupereDicoEquation(monMC):\r
  72     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
  73     listEquation, listModele,listePostTraitement=recupereDicoGenerique(monMC)\r
  74     editor=monMC.jdc.editor\r
  75 \r
  76     valeurEquationListe=editor.getValeur('Equation','Equation_Liste',('b_type_show',))\r
  77     valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_reaction_type',))\r
  78     if valeurAgingType == None :\r
  79        valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_aging_type',))\r
  80     if valeurAgingType == None : monMC.dsMaFunct = False; return\r
  81 \r
  82     listeEquationPourIhm = []\r
  83     listeReprEquationPourIhm = []\r
  84     dicoListeAffiche={}\r
  85     for equation in listEquation :\r
  86         if valeurEquationListe == 'aging_type' :\r
  87            if equation.type_vieil == valeurAgingType : \r
  88               listeEquationPourIhm.append(equation)\r
  89               listeReprEquationPourIhm.append(equation.representation)\r
  90               dicoListeAffiche[equation.representation]=equation\r
  91         else:\r
  92            if equation.type_react == valeurAgingType : \r
  93               listeEquationPourIhm.append(equation)\r
  94               listeReprEquationPourIhm.append(equation.representation)\r
  95               dicoListeAffiche[equation.representation]=equation\r
  96     change=editor.changeIntoDefMC('Equation', ('b_type_show','ListeEquation'), listeReprEquationPourIhm )\r
  97     if change :\r
  98        editor.reCalculeValiditeMCApresChgtInto('Equation', 'listeEquation', ('b_type_show',)) \r
  99        if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 100     editor.maClasseVisuEquation = classeVisuEquation(dicoListeAffiche,listEquation, listModele,listPostTraitement)\r
 101     monMC.dsMaFunct = False\r
 102 \r
 103 def afficheValeurEquation(monMC):\r
 104     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 105     editor=monMC.jdc.editor\r
 106     valeur=monMC.valeur\r
 107     if valeur == None : \r
 108        monMC.dsMaFunct = False\r
 109        return\r
 110     editor.maClasseVisuEquation.valeurEquationChoisie=valeur\r
 111     monMC.dsMaFunct = False\r
 112               \r
 113 \r
 114 def instancieChemicalFormulation(monMC):\r
 115     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 116     if monMC.valeur == False : return\r
 117 \r
 118     editor=monMC.jdc.editor\r
 119     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 120     editor.dsMaFunct = True\r
 121 \r
 122     print ('ds instancie')\r
 123     v=editor.maClasseVisuEquation.valeurEquationChoisie\r
 124     monEquation=editor.maClasseVisuEquation.dicoListeAffiche[v]\r
 125     type_react=monEquation.type_react\r
 126     type_vieil=monEquation.type_vieil\r
 127     print (v, type_react, type_vieil)\r
 128     #editor.changeIntoMCandSet('Equation', ('b_type_show','b_modification','b_modif','ChemicalFormulation'),( v,),v )\r
 129     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Reaction_Type'),type_react )\r
 130     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Aging_Type'), type_vieil )\r
 131 \r
 132     for index,valeurConstituant in enumerate(monEquation.constituants):\r
 133         valeurEquation=monEquation.equation[index] \r
 134         editor.ajoutMC(monMC.etape,'OptionnelConstituant',None,('b_type_show','b_modification','b_modif',))\r
 135         print (index,valeurConstituant,valeurEquation)\r
 136 \r
 137             #OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
 138             #    Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
 139             #    Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
 140     for index,valeurConstituant in enumerate(monEquation.const_cine_nom):\r
 141          valeurArrhe=monEquation.arrhenius[index] \r
 142          if valeurArrhe : valeurConstanteType='Arrhenius type'\r
 143          else           : valeurConstanteType='non Arrhenius type'\r
 144 \r
 145          print (index,valeurConstituant,valeurConstanteType)\r
 146             #OptionnelleConstante  = FACT (statut = 'f', max = '**',\r
 147             #     ConstanteName= SIMP (statut = 'o', typ = 'TXM',),\r
 148             #    ConstanteType =  SIMP(statut= 'o',typ= 'TXM', min=1,into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
 149     change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Commentaire'),monEquation.comment )\r
 150     print (monEquation.comment )\r
 151     #if change :\r
 152     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 153     monMC.dsMaFunct = False\r
 154     editor.dsMaFunct = False\r
 155  \r
 156 # TEMPORAIRE \r
 157 # TODO TODO TODO\r
 158 # PNPNPNPNPN\r
 159 \r
 160 \r
 161 maClasseDeModele=class_data.Modele()\r
 162 \r
 163 def recupereDicoModele(monMC):\r
 164     if monMC.valeur == None: return\r
 165     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 166     print ('je passe dans recupereDicoModele')\r
 167     listEquation, listModele,listPostTraitement=recupereDicoGenerique(monMC)\r
 168     editor=monMC.jdc.editor\r
 169     editor.maClasseVisuEquation = classeVisuEquation({},listEquation, listModele,listPostTraitement)\r
 170     monMC.dsMaFunct = False\r
 171 \r
 172 \r
 173 def creeListeEquation(monMC):\r
 174     if monMC.valeur == None: return\r
 175     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 176 \r
 177     editor=monMC.jdc.editor\r
 178 # TEMPORAIRE \r
 179 # TODO TODO TODO\r
 180     listeEquationsAAfficher=[]\r
 181     listeConstantesAAfficher=[]\r
 182     for index,equation in enumerate( editor.maClasseVisuEquation.listEquation):\r
 183         if index in maClasseDeModele.equa:\r
 184             listeEquationsAAfficher.append(equation.representation)\r
 185             listeConstantesAAfficher.append(equation.const_cine_nom)\r
 186 \r
 187     monMC.dsMaFunct = False\r
 188 \r
 189   #        listeEquation_stabilization=SIMP(statut='o', homo='SansOrdreNiDoublon', max='**', min=0 ),\r
 190 \r
 191 def recupereModeleEquation(monMC):\r
 192     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 193     if monMC.valeur==False : return\r
 194     editor=monMC.jdc.editor\r
 195     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 196 \r
 197     editor.dsMaFunct = True\r
 198     dicoListeEquationAAfficher={}\r
 199 \r
 200     for valeurReactionType in monDico['Equation_Liste']:\r
 201       dicoListeEquationAAfficher[valeurReactionType] = [] \r
 202       for index,equation in enumerate( editor.maClasseVisuEquation.listEquation):\r
 203         if equation.type_react==valeurReactionType : \r
 204            dicoListeEquationAAfficher[valeurReactionType].append(equation.representation)\r
 205     print (dicoListeEquationAAfficher)\r
 206        \r
 207     change=editor.changeIntoDefMC('Modele', ('b_type_creation','b_ajout_equation','listeEquation_initiation'),dicoListeEquationAAfficher['initiation'] )\r
 208     change=editor.changeIntoDefMC('Modele', ('b_type_creation','b_ajout_equation','listeEquation_propagation'),dicoListeEquationAAfficher['propagation'] )\r
 209     change=editor.changeIntoDefMC('Modele', ('b_type_creation','b_ajout_equation','listeEquation_termination'),dicoListeEquationAAfficher['termination'] )\r
 210     change=editor.changeIntoDefMC('Modele', ('b_type_creation','b_ajout_equation','listeEquation_stabilization'),dicoListeEquationAAfficher['stabilization'] )\r
 211     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 212     editor.dsMaFunct = False\r
 213 \r
 214 def prepareDiffusion(monMC):\r
 215     print ('je suis dans prepareDiffusion')\r
 216     if monMC.valeur==False : return\r
 217     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 218     monMC.dsMaFunct=True\r
 219     editor=monMC.jdc.editor\r
 220     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 221     editor.dsMaFunct = True\r
 222     editor.dicoCoefS={}\r
 223     editor.dicoCoefD={}\r
 224     for c in maClasseDeModele.coef[0].keys() :\r
 225         if c[0]=='S':\r
 226            clef=c[1:]\r
 227            valeur= maClasseDeModele.coef[0][c]\r
 228            editor.dicoCoefS[clef]=valeur\r
 229         if c[0]=='D':\r
 230            clef=c[1:]\r
 231            valeur= maClasseDeModele.coef[0][c]\r
 232            editor.dicoCoefD[clef]=valeur\r
 233     print (editor.dicoCoefS,editor.dicoCoefD)\r
 234     monMC.dsMaFunct=False\r
 235     editor.dsMaFunct = False\r
 236 \r
 237 \r
 238 def ajouteDiffusion(monMC):\r
 239     print ('je suis dans ajouteDiffusion')\r
 240     if monMC.valeur == None : return\r
 241     print (monMC.valeur)\r
 242     if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
 243     monMC.dsMaFunct=True\r
 244     editor=monMC.jdc.editor\r
 245     if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
 246     editor.dsMaFunct = True\r
 247 \r
 248 \r
 249     for v in monMC.valeur :\r
 250         print (v)\r
 251         mesValeurs=editor.dicoCoefS[v]\r
 252         print (editor.dicoCoefS)\r
 253         print (mesValeurs) \r
 254         MCFils='S'+v\r
 255         for e in monMC.jdc.etapes:\r
 256             if e.nom == Modele :break\r
 257 \r
 258         print (e)\r
 259         editor.ajoutDefinitionMC(e,('b_type_creation','b_diffusion'),MCFils,typ='TXM',statut='o' )\r
 260         print ('ggggg')\r
 261         editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))\r
 262         print ('______')\r
 263     if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
 264     monMC.dsMaFunct=False\r
 265     editor.dsMaFunct = False\r
 266 \r
 267 JdC = JDC_CATA(code='VP',\r
 268                execmodul=None,\r
 269                 )\r
 270 \r
 271 \r
 272   \r
 273 #---------------------------------\r
 274 Equation = PROC (nom="Equation",\r
 275       op=None,\r
 276 #---------------------------------\r
 277       Equation_DB=SIMP(statut= 'o',typ= 'TXM', into=("Approved data base", "My data base") ),\r
 278       Equation_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show equation database", "Equation creation"),),\r
 279 \r
 280       \r
 281 #     ---------------------------------------------------------------------------\r
 282        b_type_show = BLOC(condition = " Equation_Type == 'Show equation database'",\r
 283 #      ---------------------------------------------------------------------------\r
 284         Equation_Liste=SIMP(statut= 'o',typ= 'TXM', into=('reaction_type','aging_type')),\r
 285 \r
 286          b_reaction_type =  BLOC(condition = " Equation_Liste  == 'reaction_type'",\r
 287            Equation_reaction=SIMP(statut= 'o',typ= 'TXM', into=monDico['Equation_Liste'],siValide=recupereDicoEquation),\r
 288          ), # Fin b_reaction_type\r
 289 \r
 290          b_aging_type =  BLOC(condition = " Equation_Liste  == 'aging_type'",\r
 291               Equation_reaction=SIMP(statut= 'o',typ= 'TXM', into=('All', 'thermo', 'radio'),siValide=recupereDicoEquation),\r
 292          ), # Fin b_reaction_type\r
 293 \r
 294          ListeEquation = SIMP(statut='o', typ='TXM',  homo='SansOrdreNiDoublon',siValide=afficheValeurEquation),\r
 295          b_modification = BLOC(condition = " ListeEquation != None ",\r
 296            modification = SIMP(typ = bool, statut = 'o',defaut = False, fr='toto', ang='toto en anglais', siValide=instancieChemicalFormulation),\r
 297            \r
 298            b_modif = BLOC(condition = "modification == True",\r
 299             Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],),\r
 300             Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'),),\r
 301 \r
 302             OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
 303                 Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
 304                 Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
 305                ), # fin Const_Equa\r
 306             OptionnelleConstante  = FACT (statut = 'f', max = '**',\r
 307                   ConstanteName= SIMP (statut = 'o', typ = 'TXM',),\r
 308                   ConstanteType =  SIMP(statut= 'o',typ= 'TXM', min=1,into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
 309                   ),# fin ConstanteOptionnelle\r
 310             Commentaire =  SIMP (statut = 'f', typ = 'TXM', defaut = ' '),\r
 311 \r
 312            ),# fin b_modif\r
 313          \r
 314          ), # fin b_modification\r
 315        ), # Fin b_type_show\r
 316 \r
 317 \r
 318 #     ---------------------------------------------------------------------------\r
 319       b_type_creation = BLOC(condition = " Equation_Type == 'Equation creation'",\r
 320 #         ---------------------------------------------------------------------------\r
 321          Equation_Modification = FACT ( statut = 'o',\r
 322  \r
 323             ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = 'POOH -> 2P'),\r
 324 \r
 325             Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],),\r
 326             Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'),),\r
 327 \r
 328             Constituants = FACT ( statut = 'o',\r
 329                ConstituantPOOH = SIMP (statut = 'f', typ = 'TXM', into = ('POOH',), defaut= 'POOH'),\r
 330                b_pooh =  BLOC(condition = " ConstituantPOOH == 'POOH'" ,\r
 331                   Differential_Equation_POOH =  SIMP(statut= 'o',typ= 'TXM', defaut = '-ku1*POOH'),\r
 332                ), # Fin b_pooh\r
 333                ConstituantP = SIMP (statut = 'f', typ = 'TXM', into = ('P',),defaut='P'),\r
 334                b_p =  BLOC(condition = " ConstituantP == 'P'" ,\r
 335                  Differential_Equation_P =  SIMP(statut= 'o',typ= 'TXM', defaut = '2*ku1*POOH'),\r
 336                ), # Fin b_p\r
 337             OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
 338                 Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
 339                 Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
 340                ), # fin Const_Equa\r
 341             ),# Fin Constituants\r
 342 \r
 343             Constante = FACT ( statut = 'o',\r
 344                Constanteku1 = SIMP (statut = 'f', typ = 'TXM', into = ('ku1',), defaut= 'ku1'),\r
 345                b_cku1 =  BLOC(condition = "Constanteku1 == 'ku1'" ,\r
 346                   ConstanteType =  SIMP(statut= 'o',typ= 'TXM', into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
 347                   ),\r
 348                OptionnelleConstante  = FACT (statut = 'f', max = '**',\r
 349                   ConstanteName= SIMP (statut = 'o', typ = 'TXM',),\r
 350                   ConstanteType =  SIMP(statut= 'o',typ= 'TXM', min=1,into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
 351                   ),# fin ConstanteOptionnelle\r
 352             ), # fin constante\r
 353             Commentaire =  SIMP (statut = 'f', typ = 'TXM', defaut = ' '),\r
 354                   \r
 355          ), # Fin Equation_Modification\r
 356 \r
 357                  #Chemical_Formulation =  SIMP(statut= 'o',typ= 'TXM', defaut = 'POOH->P',siValide=maFuncWithArg),\r
 358                  #Type1 = SIMP(statut='o', typ = 'TXM', into=maFunc),\r
 359                  #Type2 = SIMP(statut='o', typ = 'TXM'),\r
 360 \r
 361         ),  # fin b_type_creation\r
 362                  \r
 363       \r
 364 ) # Fin Equation\r
 365 \r
 366 #---------------------------------\r
 367 Modele = PROC (nom="Modele",\r
 368       op=None,\r
 369       Modele_DB=SIMP(statut= 'o',typ= 'TXM', into=("Approved data base", "My data base"),siValide=recupereDicoModele ),\r
 370       Modele_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show modele database", "Modele creation"),siValide=creeListeEquation),\r
 371 #     ---------------------------------------------------------------------------\r
 372       b_type_creation = BLOC(condition = " Modele_Type == 'Modele creation'",\r
 373 #         ---------------------------------------------------------------------------\r
 374         technicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'],defaut=maClasseDeModele.technical_use ),\r
 375         modeleName=SIMP(statut='o',typ='TXM',defaut=maClasseDeModele.nom,),\r
 376         material=SIMP(statut='o',typ='TXM',defaut=maClasseDeModele.materiaux[0],),\r
 377         stabilizer = SIMP(typ = bool, statut = 'o',defaut = maClasseDeModele.stabilise),\r
 378         model_developed_by_for_EDF = SIMP(typ = bool, statut = 'o',defaut = maClasseDeModele.dvt_EDF[0]),\r
 379         documentation=SIMP(statut='o',typ='TXM',defaut=maClasseDeModele.reference,),\r
 380         \r
 381        # ajouter la liste des equations et le remove (il faut garder ceux qu on a enlever)\r
 382       \r
 383 \r
 384        AjoutEquation=SIMP(statut= 'o',typ= bool, defaut=False, siValide=recupereModeleEquation),\r
 385        b_ajout_equation = BLOC(condition = " AjoutEquation == True",\r
 386           listeEquation_initiation=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[] ),\r
 387           listeEquation_propagation=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[] ),\r
 388           listeEquation_termination=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[] ),\r
 389           listeEquation_stabilization=SIMP(statut='o',typ='TXM', homo='SansOrdreNiDoublon', max='**', min=0, defaut=[] ),\r
 390        ),# fin b_ajout_equation\r
 391        \r
 392         # coefficients maClasseDeModele.coef = liste de dictionnaire mais il faut prendre que le 0\r
 393         # on enleve ceux qui commence par D, S et B(casse imprtante)\r
 394         # la clef est le coef, puis les valeurs\r
 395 \r
 396         Aging_Type=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'), defaut=maClasseDeModele.type_vieil),\r
 397         Diffusion = SIMP(typ = bool, statut = 'o',defaut = maClasseDeModele.diffusion,siValide = prepareDiffusion),\r
 398 \r
 399         b_diffusion = BLOC(condition = " Diffusion == True",\r
 400          #coefficients maClasseDeModele.coef = liste de dictionnaire mais il faut prendre que le 0\r
 401         # on met ceux qui commence par D, S et pas les B ni les aitres( casse imprtante)\r
 402            listeProduitPourLaDiffusion=SIMP(statut='o', typ='TXM', max='**', min=1,homo='SansOrdreNiDoublon', into = maClasseDeModele.param_ini.keys(),siValide=ajouteDiffusion), \r
 403        ),  # fin b_diffusion\r
 404  \r
 405        ),  # fin b_type_creation\r
 406 \r
 407 \r
 408        #AjoutEquation=Fact(statut='f',\r
 409        #     Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],siValide=recupereModeleEquation),\r
 410        #), # fin AjoutEquation\r
 411 \r
 412       Commentaire =  SIMP (statut = 'f', typ = 'TXM'),\r
 413 ) # Fin Modele\r