modif pour VP

diff --git a/InterfaceQT4/editor.py b/InterfaceQT4/editor.py
index a95c1c62850e694e629b9edfdd5f5410baba1d3f..fb0acf82a07cd0642d7bbdb603215bf7da27c17b 100755 (executable)
--- a/InterfaceQT4/editor.py
+++ b/InterfaceQT4/editor.py
@@ -112,7 +112,7 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
         if self.code in ['Adao','ADAO','MAP'] : self.afficheApresInsert=True
         if self.code in ['TELEMAC',]          : self.enteteQTree='premier'
         else                                  : self.enteteQTree='complet'
-        if self.code in ['Adao','ADAO','TELEMAC'] : self.affichePlie=True
+        if self.code in ['Adao','ADAO','TELEMAC','VP'] : self.affichePlie=True
         else                                      : self.affichePlie=False
 
         self.Commandes_Ordre_Catalogue =self.readercata.Commandes_Ordre_Catalogue
@@ -420,7 +420,6 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
       # si possible on renomme l objet comme le noeud couper
 
       if (self.QWParent.edit == "couper"):
-         #print ('je pass la')
          if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
            QMessageBox.critical( self, tr("Deplacement refuse"),tr('Deplacement refuse entre 2 fichiers. Seule la copie est autorisee '))
 
@@ -521,9 +520,7 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
          nodeOuAjouter=self.node_selected[0]
          if nodeOuAjouter != self.tree.racine :
             while  nodeOuAjouter.treeParent != self.tree.racine:
-                   #print (nodeOuAjouter)
                    nodeOuAjouter=nodeOuAjouter.treeParent
-                   #print (nodeOuAjouter.parent == self.tree.racine)
          nouveau=nodeOuAjouter.appendBrother(nomEtape)
       try : 
         self.node_selected[0].setSelected(False)
@@ -993,47 +990,6 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
     # dans le JDC
         self.jdc.suppEntite(etape)
 
-    #-------------------------------------#
-    def deleteMC(self,etape,MCFils,listeAvant=()):
-    #-------------------------------------#
-    # dans le JDC
-        ouChercher=etape
-        for mot in listeAvant :
-              ouChercher=ouChercher.getChild(mot,restreint="oui")
-        monMC=ouChercher.getChild(MCFils,restreint="oui")
-        if monMC != None :  ouChercher.suppEntite(monMC)
-        ouChercher.state='changed'
-        ouChercher.isValid()
-
-    #-------------------------------------#
-    def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
-    #-------------------------------------#
-    # dans le JDC
-        ouChercher=etape
-        for mot in listeAvant :
-              ouChercher=ouChercher.getChild(mot,restreint="oui")
-        monMC=etape.getChild(ouChercher,restreint="oui")
-        if monMC== None : monMC= ouChercher.addEntite(MCFils)
-        monMC.valeur=valeurs
-        monMC.val=valeurs
-        monMC.state='changed'
-        monMC.isValid()
-
-    #----------------------------------------------#
-    def ajoutMCFact(self,etape,MCFils,listeAvant=()):
-    #----------------------------------------------#
-    # dans le JDC
-        #print ('ajoutMCFact')
-        ouChercher=etape
-        #print (ouChercher)
-        for mot in listeAvant :
-              ouChercher=ouChercher.getChild(mot,restreint="oui")
-              #print (mot)
-              #print (ouChercher)
-        monMC=etape.getChild(ouChercher,restreint="oui")
-        if monMC== None : monMC= ouChercher.addEntite(MCFils)
-        monMC.isValid()
-
 
     #-----------------------------------------
     def initSplitterSizes(self, nbWidget=3):
@@ -1115,7 +1071,6 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget):
     #-----------------------
     def getEtapeCourante(self) :
     #-----------------------
-      #print (self.tree.selectedItems())
       if len(self.tree.selectedItems()) != 1 : return None
       etape=self.tree.selectedItems()[0].item.object.getEtape()
       return etape

diff --git a/InterfaceQT4/editorSsIhm.py b/InterfaceQT4/editorSsIhm.py
index 66c2f887945d71606d14865fc82ee7ae540d0e69..4fc4772d035b52e16fa019ed534980a6aefb5ca9 100755 (executable)
--- a/InterfaceQT4/editorSsIhm.py
+++ b/InterfaceQT4/editorSsIhm.py
@@ -640,60 +640,115 @@ class JDCEditorSsIhm :
     # dans le JDC
         ouChercher=etape
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
-        monMC=ouChercher.get_child(MCFils,restreint="oui")
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
         if monMC != None :  ouChercher.suppentite(monMC)
         ouChercher.state='changed'
         ouChercher.isvalid()
 
-    #-------------------------------------#
+    #--------------------------------------------------------#
     def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
-    #-------------------------------------#
+    #--------------------------------------------------------#
     # dans le JDC
+        debug=False
+        if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
         ouChercher=etape
+        if debug : print (ouChercher)
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
-        monMC=etape.get_child(ouChercher,restreint="oui")
-        if monMC== None : monMC= ouChercher.addentite(MCFils)
+           ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
+        if monMC == None : monMC = ouChercher.addEntite(MCFils)
         monMC.valeur=valeurs
         monMC.val=valeurs
         monMC.state='changed'
         monMC.isvalid()
+        return 1
+
+    #--------------------------------------------------------#
+    def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
+    # Attention si +sieursMCFACT
+    #--------------------------------------------------------#
+    # dans le JDC
+        debug=False
+        if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
+        ouChercher=etape
+        if debug : print (ouChercher)
+        for mot in listeAvant :
+           ouChercher=ouChercher.getChild(mot,restreint="oui", debug=1)
+        # Attention si +sieursMCFACT
+        ouChercher=ouChercher[0]
+        if debug : print (ouChercher)
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
+        if monMC == None : monMC = ouChercher.addEntite(MCFils)
+        monMC.valeur=valeurs
+        monMC.val=valeurs
+        monMC.state='changed'
+        monMC.isValid()
+        return 1
 
     #----------------------------------------------#
     def ajoutMCFact(self,etape,MCFils,listeAvant=()):
     #----------------------------------------------#
     # dans le JDC
-        print ('ajoutMCFact')
         ouChercher=etape
-        print (ouChercher)
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
-              print (mot)
-              print (ouChercher)
-        monMC=etape.get_child(ouChercher,restreint="oui")
-        if monMC== None : monMC= ouChercher.addentite(MCFils)
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
+        monMC=etape.getChild(ouChercher,restreint="oui")
+        if monMC== None : monMC= ouChercher.addEntite(MCFils)
         monMC.isvalid()
 
+    #-----------------------------------------------------------------#
+    def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
+    #-----------------------------------------------------------------#
+    # pour VP
+        monObj=etape
+        for mot in listeAvant :
+              monObj=monObj.getChild(mot,restreint="oui")
+              if monObj==None : return False
+        if monObj == None : return False
+        if monObj.valeur != valeur :
+           # PNPN le setValeur fait des bugs --> pourquoi
+           #monObj.setValeur(valeur)
+           monObj.valeur=valeur
+           monObj.isValid()
+        return True
+
     #-------------------------------------------------#
     def getValeur(self,nomEtape,MCFils,listeAvant=()):
     #-------------------------------------------------#
     # dans le JDC
 
+        debug=0
         ouChercher=None
         for e in self.jdc.etapes:
             if e.nom == nomEtape : ouChercher=e; break
         if debug : print ('etape trouvee', ouChercher)
         if ouChercher==None : return None
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
               if debug : print (mot, ouChercher)
               if ouChercher==None : return None
-        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
         if debug : print ('monMC', monMC)
         if monMC== None : return None
         return monMC.valeur
 
+    #-------------------------------------------------#
+    def getMCDsEtape(self,etape,MCFils,listeAvant=()):
+    #-------------------------------------------------#
+    # dans le JDC
+
+        if etape==None : return None
+        ouChercher=etape
+        debug=0
+        for mot in listeAvant :
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
+              if debug : print (mot, ouChercher)
+              if ouChercher==None : return None
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
+        if debug : print ('monMC', monMC)
+        return monMC
+
     #-----------------------------------------------------------#
     def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
     #--------------------------------------------------------#
@@ -704,10 +759,10 @@ class JDCEditorSsIhm :
             if e.nom == nomEtape : ouChercher=e; break
         if ouChercher==None : return None
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
               #print (mot, ouChercher)
               if ouChercher==None : return None
-        monMC=ouChercher.get_child(MCFils,restreint="oui")
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
         monMC.set_valeur(valeur)
         monMC.isvalid()
 
@@ -723,10 +778,10 @@ class JDCEditorSsIhm :
         if ouChercher==None : return
 
         for mot in listeAvant :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
               if ouChercher==None : return
-        monMC=ouChercher.get_child(MCFils,restreint="oui")
-        if monMC== None : monMC= ouChercher.addentite(MCFils)
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
+        if monMC== None : monMC= ouChercher.addEntite(MCFils)
 
         monMC.definition.into=valeurs
         from Noyau.N_VALIDATOR import  IntoProtocol
@@ -743,11 +798,11 @@ class JDCEditorSsIhm :
 
         for mot in listeAvant :
             try :
-              ouChercher=ouChercher.get_child(mot,restreint="oui")
+              ouChercher=ouChercher.getChild(mot,restreint="oui")
             # Le mot clef n est pas la
             except : return 0
         try :
-           monMC=ouChercher.get_child(MCFils,restreint="oui")
+           monMC=ouChercher.getChild(MCFils,restreint="oui")
         # Le mot clef n est pas la
         except : return 0
         if monMC == None : return 0
@@ -784,23 +839,29 @@ class JDCEditorSsIhm :
         return 1
 
     #------------------------------------------------#
-    def changeIntoDefMC(self,nomEtape,listeMC,valeurs):
+    def changeIntoDefMC(self,etape,listeMC,valeurs):
     #------------------------------------------------#
     # dans le MDD
         #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
-        definitionEtape=getattr(self.jdc.cata,nomEtape)
-        ouChercher=definitionEtape
+        #definitionEtape=getattr(self.jdc.cata,nomEtape)
+        print ( 'changeIntoDefMC ',etape,listeMC,valeurs)
+        ouChercher=getattr(self.jdc.cata,etape.nom)
 
-        if len(listeMC) > 1 :
-           for mc in listeMC[0:-1]:
-             mcfact=ouChercher.entites[mc]
-             ouChercher=mcfact
-        mcAccas=ouChercher.entites[listeMC[-1]]
+        #if len(listeMC) > 1 :
+        #   for mc in listeMC[0:-1]:
+        #     mcfact=ouChercher.entites[mc]
+        #     ouChercher=mcfact
+        #mcAccas=ouChercher.entites[listeMC[-1]]
+
+        for mc in listeMC :
+            mcAccas=ouChercher.entites[mc]
+            ouChercher=mcAccas
+            if ouChercher == None : return 0
 
         if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
         else : oldValeurs=None
-        if oldValeurs==valeurs : return 0
 
+        if oldValeurs==valeurs : return 1
         mcAccas.into=valeurs
         from Noyau.N_VALIDATOR import  IntoProtocol
         mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
@@ -895,11 +956,11 @@ class JDCEditorSsIhm :
 
         ouChercher = etape
         for mot in listeMC[:-1] :
-            ouChercher=ouChercher.get_child(mot,restreint="oui")
+            ouChercher=ouChercher.getChild(mot,restreint="oui")
             if ouChercher==None : return
         MCFils=listeMC[-1]
-        monMC=ouChercher.get_child(MCFils,restreint="oui")
-        if monMC== None : monMC= etape.addentite(MCFils)
+        monMC=ouChercher.getChild(MCFils,restreint="oui")
+        if monMC== None : monMC= etape.addEntite(MCFils)
 
         monMC.definition.into=into
         monMC.valeur=valeurs

diff --git a/InterfaceQT4/eficas_go.py b/InterfaceQT4/eficas_go.py
index d7aea420395a51840183530d2c185f726b943139..e5ef13efc0f5dec216d42c27cc03af275bc194be 100755 (executable)
--- a/InterfaceQT4/eficas_go.py
+++ b/InterfaceQT4/eficas_go.py
@@ -77,6 +77,23 @@ def lanceEficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
     res=app.exec_()
     sys.exit(res)
 
+def lanceEficasMap2(code=None,fichier=None,ssCode=None,multi=True,langue='en'):
+    from Editeur  import session
+    options=session.parse(sys.argv)
+    from InterfaceQT4.qtEficas import Appli
+    app = QApplication(sys.argv)
+    Eficas=Appli(code='Map2',salome=0,ssCode='V2',multi=False,langue=langue)
+    Eficas.show()
+
+    Eficas.fileNew()
+    Eficas.ssCode='V2017'
+    Eficas.readercata.demandeCatalogue='V2017'
+    Eficas.fileNew()
+    Eficas.fileNew()
+
+
+    res=app.exec_()
+    sys.exit(res)
 
 def lanceEficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=False,langue='en'):
     """

diff --git a/InterfaceQT4/monWidgetFact.py b/InterfaceQT4/monWidgetFact.py
index 38f5805b86f4fb244296e75acfae545656752984..d756cb28cdf3539963f5c0d390cd99a8c882e3be 100644 (file)
--- a/InterfaceQT4/monWidgetFact.py
+++ b/InterfaceQT4/monWidgetFact.py
@@ -41,6 +41,9 @@ class MonWidgetFactCommun(Groupe):
       self.GroupBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
       self.parentQt.commandesLayout.insertWidget(insertIn,self)
       self.doitAfficherOptionnel=False
+      min,max=obj.getMinMax()
+      if max < 2 and  hasattr(self, 'RBPlus') : self.RBPlus.close() 
+      if max > 1 and  hasattr(self, 'RBPlus') : self.RBPlus.clicked.connect(self.ajouteMCParPB)
 
   def enterEvent(self,event):
       #print "enterEvent ", self.node.item.getLabelText()[0]
@@ -57,6 +60,14 @@ class MonWidgetFactCommun(Groupe):
       #print "delayAffiche, self.doitAfficherOptionnel = ", self.doitAfficherOptionnel
       if self.doitAfficherOptionnel and self.editor.code != "CARMELCND" :self.afficheOptionnel()
 
+  def ajouteMCParPB(self):
+      texteListeNom="+"+self.obj.nom
+      parentOuAjouter=self.parentQt
+      from .monWidgetBloc import MonWidgetBloc
+      while (parentOuAjouter and isinstance(parentOuAjouter, MonWidgetBloc)) :
+         parentOuAjouter=parentOuAjouter.parentQt
+      parentOuAjouter.ajoutMC(texteListeNom)
+
 
 class MonWidgetFact(Ui_WidgetFact,MonWidgetFactCommun):
   def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):

diff --git a/VirtualPolymer/VP_Cata_V2.py b/VirtualPolymer/VP_Cata_V2.py
index 271a46ba0622e69f27f9fdeb938486120f6a0000..93a6008a618c72c2d4c3d1b08dade0fa418cf1c6 100644 (file)
--- a/VirtualPolymer/VP_Cata_V2.py
+++ b/VirtualPolymer/VP_Cata_V2.py
@@ -1,303 +1,419 @@
-# coding: utf-8\r
-import types\r
-from Accas import *\r
-\r
-import lienDB\r
-import listesDB\r
-\r
-monDico= { 'Equation_Liste' : ('initiation', 'propagation', 'termination', 'stabilization'),\r
-           'Modele_TechnicalUse' : ('cable', 'coating', 'pipes'),\r
-           'Aging_Factor' : { 'predefinedSimulationTime' : ('40years BR top', '40years BR bottom')},\r
-           'Boundary_Conditions' : ('flux_volume','flux_surface','constant_constration','convection_flux'),\r
-           'posttraitement_Typ' : ('chimique','mecanique','physique'),\r
-         }\r
-\r
-monModele=listesDB.sModele().monModele\r
-monPost=listesDB.sModele().monPost\r
-\r
-import types\r
-class Tuple:\r
-  def __init__(self,ntuple):\r
-    self.ntuple=ntuple\r
-\r
-  def __convert__(self,valeur):\r
-    if type(valeur) == types.StringType:\r
-      return None\r
-    if len(valeur) != self.ntuple:\r
-      return None\r
-    return valeur\r
-\r
-  def info(self):\r
-    return "Tuple de %s elements" % self.ntuple\r
-\r
-\r
-JdC = JDC_CATA(code='VP',\r
-               execmodul=None,\r
-                )\r
-\r
-  \r
-#---------------------------------\r
-Equation = PROC (nom="Equation",\r
-      op=None,\r
-#---------------------------------\r
-      Equation_DB=SIMP(statut= 'o',typ= 'TXM', into=("Approved data base", "My data base") ),\r
-      #b_suite = BLOC(condition = "Equation_DB ==  'My data base' ",\r
-      Equation_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show equation database", "Equation creation"),),\r
-      #),\r
-      #b_suite_2 = BLOC(condition = "Equation_DB ==  'Approved data base' ",\r
-      #Equation_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show equation database", ),),\r
-      #),\r
-      \r
-#     ---------------------------------------------------------------------------\r
-       b_type_show = BLOC(condition = " Equation_Type == 'Show equation database'",\r
-#      ---------------------------------------------------------------------------\r
-        Equation_Liste=SIMP(statut= 'o',typ= 'TXM', into=('reaction_type','aging_type')),\r
-\r
-         b_reaction_type =  BLOC(condition = " Equation_Liste  == 'reaction_type'",\r
-           Equation_reaction=SIMP(statut= 'o',typ= 'TXM', into=monDico['Equation_Liste'],siValide=lienDB.recupereDicoEquation),\r
-         ), # Fin b_reaction_type\r
-\r
-         b_aging_type =  BLOC(condition = " Equation_Liste  == 'aging_type'",\r
-              Equation_reaction=SIMP(statut= 'o',typ= 'TXM', into=('All', 'thermo', 'radio'),siValide=lienDB.recupereDicoEquation),\r
-         ), # Fin b_reaction_type\r
-\r
-         ListeEquation = SIMP(statut='o', typ='TXM',  homo='SansOrdreNiDoublon',siValide=lienDB.afficheValeurEquation),\r
-         #ListeEquation = SIMP(statut='o', typ='TXM',  homo='SansOrdreNiDoublon'),\r
-         b_modification = BLOC(condition = " ListeEquation != None ",\r
-           modification = SIMP(typ = bool, statut = 'o',defaut = False, fr='toto', ang='toto en anglais', siValide=lienDB.instancieChemicalFormulation),\r
-           \r
-           b_modif = BLOC(condition = "modification == True",\r
-            Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],),\r
-            Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'),),\r
-            ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = 'POOH -> 2P'),\r
-\r
-            OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
-                Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
-                Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
-               ), # fin Const_Equa\r
-            OptionnelleConstante  = FACT (statut = 'f', max = '**',\r
-                  ConstanteName= SIMP (statut = 'o', typ = 'TXM',),\r
-                  ConstanteType =  SIMP(statut= 'o',typ= 'TXM', min=1,into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
-                  ),# fin ConstanteOptionnelle\r
-            Commentaire =  SIMP (statut = 'f', typ = 'TXM', defaut = ' '),\r
-\r
-\r
-           ),# fin b_modif\r
-         \r
-         ), # fin b_modification\r
-       ), # Fin b_type_show\r
-\r
-\r
-#     ---------------------------------------------------------------------------\r
-      b_type_creation = BLOC(condition = " Equation_Type == 'Equation creation'",\r
-#         ---------------------------------------------------------------------------\r
-         Equation_Modification = FACT ( statut = 'o',\r
- \r
-            ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = 'POOH -> 2P'),\r
-\r
-            Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],),\r
-            Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'),),\r
-\r
-            Constituants = FACT ( statut = 'o',\r
-               ConstituantPOOH = SIMP (statut = 'f', typ = 'TXM', into = ('POOH',)),\r
-               b_pooh =  BLOC(condition = " ConstituantPOOH == 'POOH'" ,\r
-                  Differential_Equation_POOH =  SIMP(statut= 'o',typ= 'TXM', defaut = '-ku1*POOH'),\r
-               ), # Fin b_pooh\r
-               #ConstituantP = SIMP (statut = 'f', typ = 'TXM', into = ('P',)),\r
-               #b_p =  BLOC(condition = " ConstituantP == 'P'" ,\r
-               #  Differential_Equation_P =  SIMP(statut= 'o',typ= 'TXM', defaut = '2*ku1*POOH'),\r
-               #), # Fin b_p\r
-               ConstituantP = FACT ( statut = 'f',\r
-                  ConstituantP = SIMP (statut = 'f', typ = 'TXM', into = ('P',)),\r
-                  Differential_Equation_P =  SIMP(statut= 'o',typ= 'TXM', defaut = '2*ku1*POOH'),\r
-               ), # Fin ConstituantP\r
-\r
-            OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
-                Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
-                Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
-               ), # fin Const_Equa\r
-            ),# Fin Constituants\r
-\r
-            Constante = FACT ( statut = 'o',\r
-               Constanteku1 = SIMP (statut = 'f', typ = 'TXM', into = ('ku1',), defaut= 'ku1'),\r
-               b_cku1 =  BLOC(condition = "Constanteku1 == 'ku1'" ,\r
-                  ConstanteType =  SIMP(statut= 'o',typ= 'TXM', into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
-                  ),\r
-               OptionnelleConstante  = FACT (statut = 'f', max = '**',\r
-                  ConstanteName= SIMP (statut = 'o', typ = 'TXM',),\r
-                  ConstanteType =  SIMP(statut= 'o',typ= 'TXM', min=1,into=('Arrhenius type','non Arrhenius type'),defaut='Arrhenius type'),\r
-                  ),# fin ConstanteOptionnelle\r
-            ), # fin constante\r
-            Commentaire =  SIMP (statut = 'f', typ = 'TXM', defaut = ' '),\r
-                  \r
-         ), # Fin Equation_Modification\r
-        ),  # fin b_type_creation\r
-                 \r
-      \r
-) # Fin Equation\r
-\r
-#---------------------------------\r
-Modele = PROC (nom="Modele",\r
-      op=None,\r
-      Modele_DB=SIMP(statut= 'o',typ= 'TXM', into=("Approved data base", "My data base"),siValide=lienDB.recupereDicoModele ),\r
-      Modele_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show modele database", "Modele creation"),siValide=lienDB.creeListeEquation),\r
-#     ---------------------------------------------------------------------------\r
-      b_type_creation = BLOC(condition = " Modele_Type == 'Modele creation'",\r
-#         ---------------------------------------------------------------------------\r
-        ID=FACT(statut='o',\r
-          technicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'],defaut=monModele.technical_use ),\r
-          modeleName=SIMP(statut='o',typ='TXM',defaut=monModele.nom,),\r
-          material=SIMP(statut='o',typ='TXM',defaut=monModele.materiaux[0],),\r
-          agingType=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio'), defaut=monModele.type_vieil),\r
-          stabilizer = SIMP(typ = bool, statut = 'o',defaut = monModele.stabilise),\r
-          material_thickness = SIMP(typ = 'TXM', statut = 'o',defaut = monModele.thickness, into = ['thin','thick']),\r
-          # il faudrait que position=global_jdc fonctionne\r
-          model_developed_by_for_EDF = SIMP(typ = bool, statut = 'o',defaut = monModele.dvt_EDF[0]),\r
-          documentation=SIMP(statut='o',typ='TXM',defaut=monModele.reference,),\r
-        \r
-       ), # fin ID\r
-       # ajouter la liste des equations et le remove (il faut garder ceux qu on a enlever)\r
-      \r
-      Chemical_Equation = FACT( statut='o',\r
-       Initial_Equation_List=SIMP(statut='o',typ='TXM',max="**",homo='SansOrdreNiDoublon',into=[],defaut=[], siValide=lienDB.recupereModeleEquation),\r
-\r
-       AjoutEquation=SIMP(statut= 'o',typ= bool, defaut=False, siValide=lienDB.recupereModeleEquation),\r
-       b_ajout_equation = BLOC(condition = " AjoutEquation == True",\r
-          listeEquation_initiation=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[],siValide=lienDB.ajoutDUneEquation ),\r
-          listeEquation_propagation=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[],siValide=lienDB.ajoutDUneEquation ),\r
-          listeEquation_termination=SIMP(statut='o', typ='TXM',homo='SansOrdreNiDoublon', max='**', min=0, defaut=[],siValide=lienDB.ajoutDUneEquation ),\r
-          listeEquation_stabilization=SIMP(statut='o',typ='TXM', homo='SansOrdreNiDoublon', max='**', min=0, defaut=[],siValide=lienDB.ajoutDUneEquation ),\r
-       ),# fin b_ajout_equation\r
-       \r
-      ), # fin Equation\r
-        # coefficients monModele.coef = liste de dictionnaire mais il faut prendre que le 0\r
-        # on enleve ceux qui commence par D, S et B(casse imprtante)\r
-        # la clef est le coef, puis les valeurs\r
-\r
-      \r
-      #b_material_thickness =  BLOC(condition = "material_thickness == 'thick'",\r
-      # si position=global fonctionne\r
-        Transport = FACT( statut = 'o',\r
-        #Diffusion = SIMP(typ = bool, statut = 'o',defaut = monModele.diffusion,siValide = lienDB.prepareDiffusion),\r
-        Diffusion = SIMP(typ = bool, statut = 'o',defaut = False ,siValide = lienDB.prepareDiffusion),\r
-\r
-        b_diffusion = BLOC(condition = " Diffusion == True",\r
-           listeProduitPourLaDiffusion=SIMP(statut='o', typ='TXM', max='**', min=1,homo='SansOrdreNiDoublon', into = [],siValide=lienDB.ajouteDiffusion), \r
-          ),  # fin b_diffusion\r
-\r
-        Evaporation = SIMP(typ = bool, statut = 'o',defaut = False ,siValide = lienDB.prepareDiffusion),\r
-        b_evaporation = BLOC(condition = " Evaporation == True",\r
-           listeProduitPourLEvaporation=SIMP(statut='o', typ='TXM', max='**', min=1,homo='SansOrdreNiDoublon', into = [],siValide=lienDB.ajouteEvaporation), \r
-         ),  # fin b_evaporation\r
- \r
- \r
-         ),  # fin TRANSPORT\r
-       #),  # fin b_material_thickness\r
-\r
-      Coefficients = FACT( statut = 'o',\r
-        Coef_k2  = SIMP (statut ='o', typ='R'),\r
-        Coef_ku1 = SIMP (statut ='o', typ=Tuple(2),validators = VerifTypeTuple(('R','R')),),\r
-      ),\r
-      Parametres_Initiaux = FACT( statut = 'o',\r
-        Param_POOH=SIMP (statut ='o', typ='R'),\r
-        # La liste est la meme que le INTO des listeProduitsPourlaDiffusion\r
-        # la valeur par defaut si elle existe est contenue dans modele.param_ini['POOH']\r
-      ),\r
-\r
-\r
-       #AjoutEquation=Fact(statut='f',\r
-       #     Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'],siValide=lienDB.recupereModeleEquation),\r
-       #), # fin AjoutEquation\r
-      ), # fin Creation\r
-#     ---------------------------------------------------------------------------\r
-      b_type_modification = BLOC(condition = " Modele_Type == 'Show modele database'",\r
-#         ---------------------------------------------------------------------------\r
-          technicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'],siValide=lienDB.creeListeMateriauxSelonModele),\r
-          b_technicalUse = BLOC (condition = 'technicalUse != None and technicalUse != ""',\r
-            material= SIMP (statut ='o', typ='TXM',siValide=lienDB.creeListeModelesPossibles),\r
-            modele= SIMP (statut ='o', typ='TXM',siValide=lienDB.choisitModele),\r
-            b_modele = BLOC (condition = 'modele != None and modele != ""',\r
-              action = SIMP (statut ='o', typ='TXM',into = ['display','use','modify'], siValide=lienDB.choisitActionModele),\r
-#     ---------------------------------------------------------------------------\r
-           b_type_modify = BLOC(condition = " action == 'modify'",\r
-#         ---------------------------------------------------------------------------\r
-          ID=FACT(statut='o',\r
-          modeleName=SIMP(statut='o',typ='TXM'),\r
-          technicalUse= SIMP(statut= 'o',typ= 'TXM', into=monDico['Modele_TechnicalUse'] ),\r
-          material=SIMP(statut='o',typ='TXM'),\r
-          agingType=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon', into=('All', 'thermo', 'radio')),\r
-          stabilizer = SIMP(typ = bool, statut = 'o',),\r
-          material_thickness = SIMP(typ = 'TXM', statut = 'o', into = ['thin','thick']),\r
-          # il faudrait que position=global_jdc fonctionne\r
-          model_developed_by_for_EDF = SIMP(typ = bool, statut = 'o',),\r
-          documentation=SIMP(statut='o',typ='TXM',),\r
-\r
-\r
-# il faut recopier toute la suite en changeant eventuellement le nom du modele\r
-# il faut cocher toutes les equations par defaut\r
-        \r
-              ), # fin ID\r
-             ), # fin b_type_modify\r
-#     ---------------------------------------------------------------------------\r
-           b_type_use = BLOC(condition = " action == 'use'",\r
-#         ---------------------------------------------------------------------------\r
-             simulationName=SIMP(statut='o',typ='TXM'),\r
-             outputFolder = SIMP(statut="o", typ="Repertoire",siValide=lienDB.creeCoefAModifier),\r
-            ), # fin b_type_use\r
-#     ---------------------------------------------------------------------------\r
-           b_type_use2 = BLOC(condition = " action == 'use'",\r
-#         ---------------------------------------------------------------------------\r
-            Aging_Factor = FACT(statut='o',\r
-                predefinedSimulationTime = SIMP(statut='o',typ='TXM',into=monDico['Aging_Factor']['predefinedSimulationTime'],siValide=lienDB.remplirAgingFactor),\r
-                simulationTime=SIMP(statut='o',typ='R',),\r
-                numberOfNodes=SIMP(statut='o',typ='I',val_min=3,siValide=lienDB.creeInitialParameter),\r
-                sampleThickness=SIMP(statut='o',typ='R',),\r
-                #debitOfDose=SIMP(statut='o',typ='R',),\r
-                temperature=SIMP(statut='o',typ='R',),\r
-                oxygenPressure=SIMP(statut='o',typ='R',),\r
-                polymerConcentration=SIMP(statut='o',typ='R',),\r
-                ),\r
-            Initial_Parameter = FACT(statut='o',\r
-                max='**',\r
-                ),\r
-            Boundary_Conditions_Param = FACT(statut='o',\r
-                diffusionSpecies=SIMP(statut='o',typ='TXM',defaut='O2', into=['O2',]),\r
-                nodeNumber = SIMP(statut='o',typ='I',defaut=1, into=[1]), # tjours1\r
-                Boundary_Conditions_O2_1 = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),\r
-                BC_Value_Espece_1=SIMP(statut='o',typ='R'),\r
-                nodeNumber_Espece_4 = SIMP(statut='o',typ='I',defaut=4, into=[4]), # numberOfNodes+1\r
-                Boundary_Conditions_Espece_4 = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),\r
-                BC_Value_Espece_4=SIMP(statut='o',typ='R'),\r
-                ),\r
-\r
-            ), # fin b_type_use2\r
-          ), # fin b_modele\r
-        ), # fin b_technicalUse\r
-      ), # fin modification\r
-\r
-      Commentaire =  SIMP (statut = 'f', typ = 'TXM'),\r
-) # Fin Modele\r
-#---------------------------------\r
-Posttraitement = PROC (nom="Posttraitement",\r
-      op=None,\r
-      posttraitement_DB=SIMP(statut= 'o',typ= 'TXM', into=("Approved data base", "My data base") ),\r
-      posttraitement_Type = SIMP(statut= 'o',typ= 'TXM', into=("Show post-traitement database", "post-traitement creation"),),\r
-#     ---------------------------------------------------------------------------\r
-      b_post_creation = BLOC(condition = " posttraitement_Type == 'post-traitement creation'",\r
-        posttraitement_Name=SIMP(statut= 'o',typ= 'TXM',defaut=monPost.nom,),\r
-        generic=SIMP(statut= 'o',typ= bool,defaut=monPost.general,),\r
-        posttraitement_Typ = SIMP(statut= 'o',typ= 'TXM', into=monDico['posttraitement_Typ'],homo='SansOrdreNiDoublon',max='**',defaut=monPost.type_post),\r
-        calculation= FACT(statut='o',\r
-        # il faut un fact horizontal\r
-        calculation_results=SIMP(statut= 'o',typ= 'TXM', min=0,max='**', intoSug=monPost.calculation_results,defaut=monPost.calculation_results),\r
-        results_units=SIMP(statut= 'o',typ= 'TXM', min=0,max='**', intoSug=monPost.results_units,defaut=monPost.results_units),\r
-        #integrate=SIMP(statut= 'o',typ= 'TXM', min=0,max='**', intoSug=monPost.results_units,defaut=monPost.results_units),\r
-        prerequisite=SIMP(statut= 'o',typ= 'TXM', min=0,max='**', intoSug=monPost.prerequisite,defaut=monPost.prerequisite),\r
-        \r
-        ),\r
-        constituant=SIMP(statut= 'o',typ= 'TXM', min=0,max='**', intoSug=monPost.constituants,defaut=monPost.constituants) \r
-        \r
-      )# fin b_post_creation\r
-#         ---------------------------------------------------------------------------\r
-#---------------------------------\r
-) #Posttraitement\r
+# -*- coding: utf-8 -*-
+import types
+from Accas import *
+
+import lienDB
+
+monDico= { 'Equation_Liste' : ('initiation', 'propagation', 'termination', 'stabilization'),
+           'Modele_TechnicalUse' : ('cable', 'coating', 'pipes'),
+           'Aging_Factor' : { 'predefinedSimulationTime' : ('40years BR top', '40years BR bottom')},
+           'Boundary_Conditions' : ('flux_volume','flux_surface','constant_constration','convection_flux'),
+           'posttraitement_Typ' : ('chimique','mecanique','physique'),
+         }
+
+from mapy.virtual_polymer_common import class_data
+monMechanisticModel=class_data.Modele()
+monMechanisticEquation=class_data.Equation()
+if monMechanisticEquation.comment == "" : monMechanisticEquation.comment = ' ' 
+
+def chercheConstituant(laClasse):
+    lesArgs={}
+    lesArgs['statut']='o'
+    for constituant in laClasse.constituants :
+       monIndex=laClasse.constituants.index(constituant)
+       valdefaut=laClasse.equation[monIndex] 
+       monSimp=SIMP(statut = 'o', typ = bool, defaut=True)
+       lesArgs[constituant]=monSimp
+
+       lesArgsBloc={}
+       nomEquation = ' differentiel_'+constituant
+       monSimp2 = SIMP(statut= 'o',typ= 'TXM', defaut = valdefaut)
+       laCondition= constituant+' == True'
+       lesArgsBloc['condition']=laCondition
+       lesArgsBloc[nomEquation]=monSimp2
+       nomBloc     = 'b_'+constituant
+       leBloc = BLOC(**lesArgsBloc)
+       lesArgs[nomBloc]=BLOC(**lesArgsBloc)
+    return FACT(**lesArgs)
+
+def chercheConstantes(laClasse):
+    lesArgs={}
+    lesArgs['statut']='o'
+    for constante in laClasse.const_cine_nom :
+       monSimp=SIMP(statut = 'o', typ = bool, defaut=True)
+       lesArgs[constante]=monSimp
+    return FACT(**lesArgs)
+       
+
+import types
+class Tuple:
+  def __init__(self,ntuple):
+    self.ntuple=ntuple
+
+  def __convert__(self,valeur):
+    if type(valeur) == types.StringType:
+      return None
+    if len(valeur) != self.ntuple:
+      return None
+    return valeur
+
+  def info(self):
+    return "Tuple de %s elements" % self.ntuple
+
+
+JdC = JDC_CATA(code='VP',
+               execmodul=None,
+                )
+
+# ------------------------------------------
+Database =  PROC (nom="Database", op=None, 
+# ------------------------------------------
+       Database_Type = SIMP(statut= 'o',typ= 'TXM', into=("Local database", "Standard database"),),
+       Model_Type    = SIMP(statut= 'o',typ= 'TXM', into=("master model", "analytic model" ,"mechanistic model") ),
+
+
+#     ------------------------------------------------------------------------
+      b_Model_Mechanistic = BLOC(condition = "Model_Type == 'mechanistic model'",
+#     ------------------------------------------------------------------------
+          Type_chgt   = SIMP (statut= 'o',typ= 'TXM',into=('modify equation', 'create equation', 'modify model', 'create model'),), 
+
+         b_creation_equation = BLOC (condition  = 'Type_chgt == "create equation"',
+          # toutes les valeurs sont par defaut class_data.Equation
+          # generer le catalogue avec un fact
+          # Aging_Type type_vieil, 
+            Creation = FACT ( statut = 'o',
+            ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = monMechanisticEquation.representation ),
+            Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max=1, into=('All', 'thermo', 'radio'), defaut = monMechanisticEquation.type_vieil[0]),
+            Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max=1, into=monDico['Equation_Liste'], defaut = monMechanisticEquation.type_react),
+            Constituants = chercheConstituant(monMechanisticEquation), 
+            New = SIMP (statut = 'o', typ = bool, defaut=False),
+            b_new =  BLOC(condition = " New == True" ,
+               Constituant = FACT ( statut = 'o', min=1, max='**',
+               Name =  SIMP(statut= 'o',typ= 'TXM'),
+               Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),
+                                 ),
+                ), # b new
+
+            Constantes = chercheConstantes(monMechanisticEquation), 
+            New_Cst = SIMP (statut = 'o', typ = bool, defaut=False),
+            b_new_cst =  BLOC(condition = " New_Cst == True" ,
+            Constante = FACT ( statut = 'o', min=1, max='**',
+               Name  = SIMP (statut = 'o', typ = 'TXM'),
+                        ), # fin constante
+            ),  #fin b_new 
+
+            Arrhenius = SIMP (statut = 'o', typ = bool, defaut=monMechanisticEquation.arrhenius),
+            Comment   = SIMP(statut= 'o',typ= 'TXM', defaut = monMechanisticEquation.comment),
+         ), # fin creation mechanistic model
+       ), # fin b_create_equation
+
+       b_modify_equation = BLOC (condition  = 'Type_chgt == "modify equation"',
+# les valeurs par defaut seront lues dans la base de données
+            Filtre = FACT (statut='o',
+                Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste'], siValide=lienDB.remplitMechanisticModifyEquationListeEquation),
+# Filtre getMechanisticEquation(Reaction_Type) 
+# diictionnaire key : nom de l equation / valeur classe instancies liste de nom d'equation
+                Equation_List=SIMP(statut= 'o',typ= 'TXM', siValide=lienDB.remplitModificationEquation),
+            ),
+            # lorsque le choix est fait on peut recuperer les valeurs par defaut
+
+            #ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = 'POOH -> 2P'),
+            Modification = FACT (statut='o',
+            ChemicalFormulation = SIMP(statut='o', typ='TXM', ), # classe.representation
+            Reaction_Type=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Equation_Liste']), # classe.type_react
+            Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max=1, into=('All', 'thermo', 'radio'),), # classe.type_vieil
+
+            Constituants = FACT ( statut = 'o', # classe.constituants --> liste de nom. les equations sont dans le meme ordre self.equation
+               POOH = SIMP (statut = 'o', typ = bool, defaut=False),
+               b_pooh =  BLOC(condition = " POOH == True" ,
+                  Differential_Equation_POOH =  SIMP(statut= 'o',typ= 'TXM', defaut = '-ku1*POOH'),
+                           ), # Fin b_pooh
+               PO = SIMP (statut = 'o', typ = bool, defaut=False),
+               b_po =  BLOC(condition = " PO == True" ,
+                  Differential_Equation_PO =  SIMP(statut= 'o',typ= 'TXM', defaut = '-ku1*POOH'),
+                           ), # Fin b_po
+               New = SIMP (statut = 'o', typ = bool, defaut=False),
+               b_new =  BLOC(condition = " New == True" ,
+                 Constituant = FACT ( statut = 'o', min=1, max='**',
+                   Name  = SIMP (statut = 'o', typ = 'TXM'),
+                   Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),
+                                    ), # Fin Constituant
+                          ), # Fin b_new
+                      ),# Fin Constituants
+
+            Constantes = FACT ( statut = 'o', # self.const_cine_nom
+               KU1 = SIMP (statut = 'o', typ = bool, defaut=False),
+               New = SIMP (statut = 'o', typ = bool, defaut=False),
+               b_new =  BLOC(condition = " New == True" ,
+                 Constante = FACT ( statut = 'o', min=1, max='**',
+                   Name  = SIMP (statut = 'o', typ = 'TXM'),
+                                 ), # fin constante
+                    ),  #fin b_new 
+               ), # fin constantes
+            Arrhenius = SIMP (statut = 'o', typ = bool, ), # classe.arrhenius[0]
+            Comment   = SIMP(statut= 'o',typ= 'TXM',), # classe.comment
+             ), # fin modification
+          ), # fin b_modify_equation
+
+
+         b_create_model = BLOC (condition  = 'Type_chgt == "create model"',
+# Filtre getMechanisticTechnicalUse(Filtre_TechnicalUse) 
+# dictionnaire key : nom du modele  / valeur classe instancies liste de nom modele 
+# la classe par defaut getDefaultMechanistic
+# renvoie un obj instancie
+          # toutes les valeurs sont par defaut class_data.Equation
+          # generer le catalogue avec un fact
+             Creation = FACT (statut='o',
+             ID=FACT (statut='o',
+               Name  =SIMP(statut='o',typ='TXM'), # obj.nom 
+                Material=SIMP(statut='o',typ='TXM',),# obj.materiaux[0]
+                TechnicalUse = SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse']),#defaut=obj.technical_use 
+                Reference=SIMP(statut='o',typ='TXM',), # defaut=monModele.reference, momModele = obj par la suite
+                Model_Developed_For_EDF = SIMP(typ = bool, statut = 'o'), #defaut = monModele.dvt_EDF[0]
+                Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max=1, into=('all', 'thermo', 'radio'),), # defaut = monModele.type_vieil
+# attention c est une liste --> a reflechir
+                Stabilizer = SIMP(typ = bool, statut = 'o'), #,defaut = monModele.stabilise
+                material_thickness = SIMP(typ = 'TXM', statut = 'o', into = ['thin','thick']), # monModele.thickness
+                Diffusion = SIMP(typ = bool, statut = 'o'),# defaut = monModele.diffusion  ,siValide = lienDB.prepareDiffusion
+                Evaporation = SIMP(typ = bool, statut = 'o'), # defaut monModele.evaporation
+                Comment   = SIMP(statut= 'o',typ= 'TXM',), # classe.comment
+                ), #fin id
+              Equations = FACT (statut = 'o',
+# remplir avec getEquation sur modele
+# dictionnaire avec comme clef 'base' puis initiation ...
+                Liste=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['POOH -> 2P  [k]' , 'A   [K5,Y5]', 'B', 'C']),
+# quand coche je recupere le nom entre crochet + split sur , attention sans blanc
+# et on cree le SIMP apres pour recuperer la valeur
+                K5=SIMP (statut = 'o', typ = 'R' ),
+               New = SIMP (statut = 'o', typ = bool, defaut=False),
+# 
+               b_new =  BLOC(condition = " New == True" ,
+                 Add=FACT(statut = 'o',max='**',
+                 Filtre = SIMP(statut= 'o',typ= 'TXM',into=monDico['Equation_Liste']),
+                 Equations=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['POOH -> 2P' , 'A', 'B', 'C'])
+                 )
+                ), # b new
+                ) # fin equations
+              ), #fin creation
+             ), # fin create model
+
+         b_modify_model = BLOC (condition  = 'Type_chgt == "modify model"',
+# Filtre getMechanisticTechnicalUse(Filtre_TechnicalUse) 
+# dictionnaire key : nom du modele  / valeur classe instancies liste de nom modele 
+# la classe par defaut getDefaultMechanistic
+# renvoie un obj instancie
+            Filtre = FACT (statut='o',
+             TechnicalUse=SIMP(statut= 'o',typ= 'TXM', min=1,into=monDico['Modele_TechnicalUse'],),
+# si valide
+             ModeleName=SIMP(statut='o',typ='TXM',into=['A','B']), # a choisir dans la liste des clefs
+              ),
+             Modification = FACT (statut='o',
+             ID=FACT (statut='o',
+               Name  =SIMP(statut='o',typ='TXM'), # obj.nom 
+                Material=SIMP(statut='o',typ='TXM',),# obj.materiaux[0]
+                TechnicalUse = SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse']),#defaut=obj.technical_use 
+                Reference=SIMP(statut='o',typ='TXM',), # defaut=monModele.reference, momModele = obj par la suite
+                Model_Developed_For_EDF = SIMP(typ = bool, statut = 'o'), #defaut = monModele.dvt_EDF[0]
+                Aging_Type=SIMP(statut= 'o',typ= 'TXM', min=1,max=1, into=('all', 'thermo', 'radio'),), # defaut = monModele.type_vieil
+# attention c est une liste --> a reflechir
+                Stabilizer = SIMP(typ = bool, statut = 'o'), #,defaut = monModele.stabilise
+                material_thickness = SIMP(typ = 'TXM', statut = 'o', into = ['thin','thick']), # monModele.thickness
+                Diffusion = SIMP(typ = bool, statut = 'o'),# defaut = monModele.diffusion  ,siValide = lienDB.prepareDiffusion
+                Evaporation = SIMP(typ = bool, statut = 'o'), # defaut monModele.evaporation
+                Comment   = SIMP(statut= 'o',typ= 'TXM',), # classe.comment
+                ), #fin id
+              Equations = FACT (statut = 'o',
+# remplir avec getEquation sur modele
+# dictionnaire avec comme clef 'base' puis initiation ...
+                Liste=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['POOH -> 2P  [k]' , 'A   [K5,Y5]', 'B', 'C']),
+# quand coche je recupere le nom entre crochet + split sur , attention sans blanc
+# et on cree le SIMP apres pour recuperer la valeur
+                K5=SIMP (statut = 'o', typ = 'R' ),
+               New = SIMP (statut = 'o', typ = bool, defaut=False),
+# 
+               b_new =  BLOC(condition = " New == True" ,
+                 Add=FACT(statut = 'o',max='**',
+                 Filtre = SIMP(statut= 'o',typ= 'TXM',into=monDico['Equation_Liste']),
+                 Equations=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['POOH -> 2P' , 'A', 'B', 'C'])
+                 )
+                ), # b new
+                ) # fin equations
+              ), #fin modification
+             ), # fin modify model
+
+      ), # Fin mechanistic 
+#     ------------------------------------------------------------------------
+      b_Model_Analytic = BLOC(condition = "Model_Type == 'analytic model'",
+          Type_chgt   = SIMP (statut= 'o',typ= 'TXM',into=('modify equation', 'create equation', 'modify model', 'create model') ),
+
+         b_creation_equation = BLOC (condition  = 'Type_chgt == "create equation"',
+          Creation = FACT(statut = 'o',
+             Name=SIMP(statut= 'o',typ= 'TXM',),   # defaut o.nom
+             Equation_Type = SIMP(statut= 'o',typ= 'TXM',into=monDico['posttraitement_Typ']), # defaut o.type_equa
+             PostProcessing = SIMP (statut = 'o', typ = bool,),# o.post_processing 
+             Calculation_Result = SIMP(statut= 'o',typ= 'TXM'), # defaut o.calculation_result
+# dans o.parameters on a une liste
+             Parameters=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['A', 'Ea', 'C']),
+             New = SIMP (statut = 'o', typ = bool, defaut=False),
+             b_new =  BLOC(condition = " New == True" ,
+               Param = FACT(statut = 'o', max='**',
+                 Name=SIMP(statut= 'o',typ= 'TXM',), 
+               ), #param
+             ),  # b_new
+             Equation = SIMP(statut= 'o',typ= 'TXM'), # defaut o.equation
+             Universal_Constants=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['A', 'B', 'C']),
+             Results_Unit = SIMP(statut= 'o',typ= 'TXM'), # defaut o.results_unit
+             Integrate = SIMP (statut = 'o', typ = bool),# defaut o.integrate
+             Comment = SIMP(statut= 'o',typ= 'TXM'), # defaut o.comment
+          ),# Fact creation
+         ), #bloc b_creation_equation
+
+         b_modification_equation = BLOC (condition  = 'Type_chgt == "modify equation"',
+          Filtre = FACT(statut = 'o',
+             Equation_Type = SIMP(statut= 'o',typ= 'TXM',into=monDico['posttraitement_Typ']), # defaut o.type_equa
+             Equation_Choice = SIMP(statut= 'o',typ= 'TXM',into=['A','B','C']),
+          ),
+          Modification = FACT(statut = 'o',
+             Name=SIMP(statut= 'o',typ= 'TXM',),   # defaut o.nom
+             Equation_Type = SIMP(statut= 'o',typ= 'TXM',into=monDico['posttraitement_Typ']), # defaut o.type_equa
+             PostProcessing = SIMP (statut = 'o', typ = bool,),# o.post_processing 
+             Calculation_Result = SIMP(statut= 'o',typ= 'TXM'), # defaut o.calculation_result
+# dans o.parameters on a une liste
+             Parameters=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['A', 'Ea', 'C']),
+             New = SIMP (statut = 'o', typ = bool, defaut=False),
+             b_new =  BLOC(condition = " New == True" ,
+               Param = FACT(statut = 'o', max='**',
+                 Name=SIMP(statut= 'o',typ= 'TXM',), 
+               ), #param
+             ),  # b_new
+             Equation = SIMP(statut= 'o',typ= 'TXM'), # defaut o.equation
+             Universal_Constants=SIMP(statut= 'o',typ='TXM', min=1,max='**', homo='SansOrdreNiDoublon',into =['A', 'B', 'C']),
+             Results_Unit = SIMP(statut= 'o',typ= 'TXM'), # defaut o.results_unit
+             Integrate = SIMP (statut = 'o', typ = bool),# defaut o.integrate
+             Comment = SIMP(statut= 'o',typ= 'TXM'), # defaut o.comment
+          ),# Fact Modification
+
+         ), #bloc b_modification_equation
+      ), # Fin model analytic
+#     ------------------------------------------------------------------------
+#        ---------------------------------------------------------------------------
+
+      b_model_master=BLOC(condition = 'Model_Type == "master model"',
+          Type_chgt         = SIMP (statut= 'o',typ= 'TXM',into=('modify model', 'create model') ),
+      ),
+)
+            
+
+# ----------------------------------------------
+Calculation =  PROC (nom="Calculation", op=None, 
+# ----------------------------------------------
+      Database=SIMP(statut= 'o',typ= 'TXM', into=("local database", "standard database") ),
+      Model=SIMP(statut= 'o',typ= 'TXM', into=("master model", "analytic model" ,"mechanistic model"),),
+      #b_Model_Name = BLOC(condition = 'Model in ("master model","mechanistic model")',
+      #b_Model_Name_1 = BLOC(condition = 'Model == "master model"',
+      # pose un pb si 2 blocs sont generes ???
+      #    TechnicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'],),#defaut=monModele.technical_use ,
+      #    ModeleName=SIMP(statut='o',typ='TXM',),#defaut=monModele.nom,,
+# filtre_calculation_mechanistic - > 3 dictionnaires
+# la clef du 1er niveau est le modele qui remplit SimulationName
+      #),
+
+
+#   MASTER MODEL
+      b_simulation_modele = BLOC(condition = 'Model == "master model"',
+           TechnicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'],),#defaut=monModele.technical_use ,
+           ModeleName=SIMP(statut='o',typ='TXM',),#defaut=monModele.nom,,
+          Analytical_Equations =  FACT(statut= 'o', max='**',
+                   Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Equation A"),
+                   Clef1=SIMP(statut='o',typ='R'),
+                   Clef2=SIMP(statut='o',typ='R'),
+                ),
+            ChemicalKinetics =  FACT ( statut = 'o',
+                SimulationName=SIMP(statut='o',typ='TXM'),
+                OutputFolder = SIMP(statut="o", typ="Repertoire"),
+                Time=SIMP(statut='o',typ='R',),
+                Temperature=SIMP(statut='o',typ='R',),
+                DebitOfDose=SIMP(statut='o',typ='R',),
+                Thickness=SIMP(statut='o',typ='R',),
+                Dicretization= SIMP(statut='o',typ='R',),
+# remplir les equations
+             InitialValue = SIMP(statut ='o', typ=Tuple(2),validators = VerifTypeTuple(('TXM','R')),max='**'),
+           
+             Boundary_Conditions = FACT(statut='o',
+                Product=FACT(statut='o', max='**',
+# a remplir avec le filtre une liste des boundary
+#       -----------------------------------
+                Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Diffusion Product"),
+                Node_0 = FACT (statut='o',
+                Boundary_Condition_Type = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),
+                Value=SIMP(statut='o',typ='R',defaut=0),
+                             ),
+                Node_N = FACT (statut='o',
+                Boundary_Condition_Type = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),
+                Value=SIMP(statut='o',typ='R',defaut=0),
+                             ),
+                 ),
+              ),
+          ),# fin ChemicalKinetics
+          Analytical_Equations_PostTreatment =  FACT(statut= 'o', max='**',
+                   Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Equation A"),
+                   InitialValue = SIMP(statut ='o', typ=Tuple(2),validators = VerifTypeTuple(('TXM','R')),max='**'),
+                   Clef1=SIMP(statut='o',typ='R'),
+                   Clef2=SIMP(statut='o',typ='R'),
+           ),
+      ), # fin bloc b_simulation_modele
+
+
+
+#     MECHANISTIC MODEL
+# filtre_calculation_mechanistic - > 3 dictionnaires
+# la clef du 1er niveau est le modele qui remplit SimulationName
+# 
+      b_mechanistic = BLOC(condition = 'Model == "mechanistic model"',
+            TechnicalUse= SIMP(statut= 'o',typ= 'TXM',into=monDico['Modele_TechnicalUse'], siValide=lienDB.remplitMechanisticModeleName),#defaut=monModele.technical_use ,
+            ModeleName=SIMP(statut='o',typ='TXM', siValide = lienDB.remplitChimicalKineticsMechanistic),#defaut=monModele.nom,,
+            ChimicalKinetics =  FACT ( statut = 'o',
+                SimulationName=SIMP(statut='o',typ='TXM'),
+                OutputFolder = SIMP(statut="o", typ="Repertoire"),
+                Time=SIMP(statut='o',typ='R',),
+                Temperature=SIMP(statut='o',typ='R',),
+# si dans le dictionnaire debit_of_dose = True je rentre la ligne suivante
+                DebitOfDose=SIMP(statut='f',typ='R',),
+                Thickness=SIMP(statut='o',typ='R',),
+                Dicretization= SIMP(statut='o',typ='R',),
+# initial_parameter pour remplir cela
+                InitialValue = SIMP(statut ='o', typ=Tuple(2),validators = VerifTypeTuple(('TXM','R')),max='**'),
+              ),
+           
+# si la liste est vide pas de Boundary_Conditions_Param sinon on cree les products
+      Boundary_Conditions_Param = FACT(statut='f',
+           Product=FACT(statut='o', max='**',
+# a remplir avec le filtre une liste des boundary qui sont contenues dans diffusion du dico de remplitChimicalKinetics
+#       -----------------------------------
+                Consigne = SIMP(statut ="o", homo="information", typ="TXM", defaut = "Diffusion Product"),
+                Node_0 = FACT (statut='o',
+                Boundary_Condition_Type = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),
+                Value=SIMP(statut='o',typ='R',defaut=0),
+                ),
+                Node_N = FACT (statut='o',
+                Boundary_Condition_Type = SIMP(statut='o',typ='TXM',into=monDico['Boundary_Conditions']),
+                Value=SIMP(statut='o',typ='R',defaut=0),
+                ),
+            ),
+        ),
+      ), # fin bloc b_simulation_modele
+
+#     ANALYTIC MODEL
+      b_analytic_model = BLOC(condition = 'Model  == "analytic model"',
+            Equation_Ty =  SIMP(statut= 'o',typ= 'TXM',into=monDico['posttraitement_Typ'],siValide=lienDB.remplitAnalyticModeleName),
+            ModeleName=SIMP(statut='o',typ='TXM', siValide=lienDB.remplitChimicalKineticsAnalytic,),
+            ChimicalKinetics =  FACT ( statut = 'o',
+                SimulationName=SIMP(statut='o',typ='TXM'),
+                OutputFolder = SIMP(statut="o", typ="Repertoire"),
+# remplir les equations
+# dictionnaire cief de filtre_calculation_analitic avec clef = clef1, clef2... et valeur = coef[cle1]
+                Coefficients = SIMP(statut ='o', typ=Tuple(2),validators = VerifTypeTuple(('TXM','R')),max='**'),
+             ),
+      ), # fin bloc b_analytic_model
+
+)

diff --git a/VirtualPolymer/lienDB.py b/VirtualPolymer/lienDB.py
index b834fc4d93c77be8e9b8800b3efd85075b7d85cb..21dcffc6aa8a46cf1cff386fb3b2d09a72896211 100644 (file)
--- a/VirtualPolymer/lienDB.py
+++ b/VirtualPolymer/lienDB.py
@@ -1,537 +1,155 @@
-# coding: utf-8\r
-\r
-import types\r
-import sys,os\r
-\r
-import listesDB\r
-\r
-\r
-maClasseDelistesDB = listesDB.classeListesDB()\r
-monModele=listesDB.sModele().monModele\r
-monPost=listesDB.sModele().monPost\r
-\r
-import types\r
-class Tuple:\r
-  def __init__(self,ntuple):\r
-    self.ntuple=ntuple\r
-\r
-  def __convert__(self,valeur):\r
-    if type(valeur) == types.StringType:\r
-      return None\r
-    if len(valeur) != self.ntuple:\r
-      return None\r
-    return valeur\r
-\r
-  def info(self):\r
-    return "Tuple de %s elements" % self.ntuple\r
-\r
-  __repr__=info\r
-  __str__=info\r
-\r
-\r
-dicoAgingFactor={ '40years BR top' : {'temperature' : 50, 'simulationTime' : 350640}}\r
-\r
-# --------------------------------------\r
-# Fonctions appellees depuis le catalogue\r
-# --------------------------------------\r
- \r
-# --------------------------------------\r
-# Dans Equation\r
-# --------------------------------------\r
-\r
-def recupereDicoEquation(monMC):\r
-    # Equation_reaction (ds 2 blocs)\r
-    #  ou dans Equation b_type_show b_reaction_type\r
-    #  ou dans Equation b_type_show b_aging_type\r
-\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    monMC.dsMaFunct = True\r
-\r
-    valeurDB=editor.getValeur('Equation','Equation_DB',())\r
-    maClasseDelistesDB.metAJour(valeurDB)\r
-    listEquation=maClasseDelistesDB.getListEquation()\r
-\r
-    valeurEquationListe=editor.getValeur('Equation','Equation_Liste',('b_type_show',))\r
-    valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_reaction_type',))\r
-    if valeurAgingType == None :\r
-       valeurAgingType=editor.getValeur('Equation','Equation_reaction',('b_type_show','b_aging_type',))\r
-    if valeurAgingType == None : monMC.dsMaFunct = False; return\r
-\r
-    listeEquationPourIhm = []\r
-    listeReprEquationPourIhm = []\r
-    dicoListAffiche = {}\r
-   \r
-    for equation in listEquation :\r
-        if valeurEquationListe == 'aging_type' :\r
-           if equation.type_vieil == valeurAgingType : \r
-              listeEquationPourIhm.append(equation)\r
-              listeReprEquationPourIhm.append(equation.representation)\r
-              dicoListAffiche[equation.representation]=equation\r
-        else:\r
-           if equation.type_react == valeurAgingType : \r
-              listeEquationPourIhm.append(equation)\r
-              listeReprEquationPourIhm.append(equation.representation)\r
-              dicoListAffiche[equation.representation]=equation\r
-    maClasseDelistesDB.dicoListAffiche = dicoListAffiche\r
-\r
-    change=editor.changeIntoDefMC('Equation', ('b_type_show','ListeEquation'), listeReprEquationPourIhm )\r
-    if change :\r
-       editor.reCalculeValiditeMCApresChgtInto('Equation', 'listeEquation', ('b_type_show',)) \r
-       if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-    monMC.dsMaFunct = False\r
-\r
-def afficheValeurEquation(monMC):\r
-    # Equation b_modification modification\r
-    print (monMC)\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    valeur=monMC.valeur\r
-    if valeur == None : return\r
-    maClasseDelistesDB.valeurEquationChoisie=str(valeur)\r
-    monEquation=maClasseDelistesDB.dicoListAffiche[str(valeur)]\r
-\r
-    aAfficher=str(monEquation)\r
-    editor=monMC.jdc.editor\r
-    editor._viewText(aAfficher, "Id",largeur=80,hauteur=300)\r
-    \r
-    monMC.dsMaFunct = False\r
-              \r
-\r
-def instancieChemicalFormulation(monMC):\r
-    print ('instancieChemicalFormulation pour ', monMC.nom)\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur == False : return\r
-\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    editor.dsMaFunct = True\r
-\r
-    for e in monMC.jdc.etapes:\r
-        if e.nom == 'Equation' :break\r
-    print ('ds instancie')\r
-    v=maClasseDelistesDB.valeurEquationChoisie\r
-    monEquation=maClasseDelistesDB.dicoListAffiche[v]\r
-    type_react=monEquation.type_react\r
-    type_vieil=monEquation.type_vieil\r
-\r
-    editor.changeIntoMCandSet('Equation', ('b_type_show','b_modification','b_modif','ChemicalFormulation'),( v,),v )\r
-    print ("je passe la")\r
-    change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Reaction_Type'),type_react )\r
-    change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Aging_Type'), type_vieil )\r
-\r
-    for index,valeurConstituant in enumerate(monEquation.constituants):\r
-        valeurEquation=monEquation.equation[index] \r
-        \r
-        #PNPNPN --> decider des noms SVP ave un nom python\r
-        monMcl1=('Constituant','TXM',{'statut':'o','defaut':valeurConstituant})\r
-        monMcl2=('Differential_Equation','TXM',{'statut':'o','defaut':valeurEquation})\r
-        listeMC=(monMcl1,monMcl2)\r
-        editor.ajoutDefinitionMCFact ('Equation',('b_type_show','b_modification','b_modif',),valeurConstituant,listeMC,statut='f')\r
-        #editor.ajoutMCFact (e,('b_type_show','b_modification','b_modif',),valeurConstituant)\r
-        print (index,valeurConstituant,valeurEquation)\r
-\r
-            #OptionnelConstituant =  FACT ( statut = 'f',max = '**',\r
-            #    Constituant = SIMP (statut = 'o', typ = 'TXM'),\r
-            #    Differential_Equation =  SIMP(statut= 'o',typ= 'TXM'),\r
-\r
-    for index,valeurConstituant in enumerate(monEquation.const_cine_nom):\r
-         valeurArrhe=monEquation.arrhenius[index] \r
-         if valeurArrhe : valeurConstanteType='Arrhenius type'\r
-         else           : valeurConstanteType='non Arrhenius type'\r
-         monMcl1=('ConstanteName','TXM',{'statut':'o','defaut':valeurConstituant})\r
-         monMcl2=('ConstanteType','TXM',{'statut':'o','defaut':valeurConstanteType,'into': ('Arrhenius type','non Arrhenius type') })\r
-         listeMC=(monMcl1,monMcl2)\r
-         editor.ajoutDefinitionMCFact ('Equation',('b_type_show','b_modification','b_modif',),valeurConstituant,listeMC,statut='f')\r
-         #editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))\r
-\r
-\r
-    change=editor.changeDefautDefMC('Equation', ('b_type_show','b_modification','b_modif','Commentaire'),monEquation.comment )\r
-    print (monEquation.comment )\r
-    if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-\r
-    monMC.dsMaFunct = False\r
-    editor.dsMaFunct = False\r
- \r
-\r
-\r
-\r
-def recupereDicoModele(monMC):\r
-    if monMC.valeur == None: return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    monMC.dsMaFunct = True\r
-    print ('je passe dans recupereDicoModele')\r
-\r
-    editor=monMC.jdc.editor\r
-    valeurDB=editor.getValeur('Modele','Modele_DB',())\r
-    maClasseDelistesDB.metAJour(valeurDB)\r
-\r
-    print ('fin recupereDicoModele')\r
-    monMC.dsMaFunct = False\r
-\r
-\r
-def creeListeEquation(monMC):\r
-    if monMC.valeur == None: return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    editor.dsMaFunct = True\r
-    print ('debut de creeListeEquation')\r
-\r
-    listeEquationsAAfficher=[]\r
-    listeConstantesAAfficher=[]\r
-    listeInitialEquations=[]\r
-\r
-    listEquation=maClasseDelistesDB.getListEquation()\r
-    for index,equation in enumerate( listEquation):\r
-        if index in monModele.equa:\r
-            listeEquationsAAfficher.append(equation.representation)\r
-            listeConstantesAAfficher.append(equation.const_cine_nom)\r
-            t=equation.representation+'\t\t\t\t    '+str(equation.const_cine_nom)\r
-            listeInitialEquations.append(t)\r
-\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','Initial_Equation_List'),listeInitialEquations )\r
-    maClasseDelistesDB.listeEquationsAAfficher = listeEquationsAAfficher\r
-    maClasseDelistesDB.listeConstantesAAfficher = listeConstantesAAfficher\r
-    monMC.dsMaFunct = False\r
-    print ('fin de creeListeEquation')\r
-\r
-    editor.dsMaFunct = False\r
-\r
-  #        listeEquation_stabilization=SIMP(statut='o', homo='SansOrdreNiDoublon', max='**', min=0 ),\r
-\r
-def recupereModeleEquation(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur==False : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    editor.dsMaFunct = True\r
-    print ('je suis dans  recupereModeleEquation')\r
-\r
-    editor.dsMaFunct = True\r
-    dicoListeEquationAAfficher={}\r
-\r
-    from VP_Cata_V2 import monDico\r
-    listEquation=maClasseDelistesDB.getListEquation()\r
-    for valeurReactionType in monDico['Equation_Liste']:\r
-      dicoListeEquationAAfficher[valeurReactionType] = [] \r
-      for index,equation in enumerate( listEquation):\r
-        if equation.type_react==valeurReactionType : \r
-           dicoListeEquationAAfficher[valeurReactionType].append(equation.representation)\r
-           maClasseDelistesDB.dictParametresInitiaux[equation.representation]=equation\r
-    #print (dicoListeEquationAAfficher)\r
-    #print('maClasseDelistesDB.dictParametresInitiaux', maClasseDelistesDB.dictParametresInitiaux)\r
-    prepareDiffusionSansMC(editor,monMC.nom)\r
-       \r
-    change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_initiation'),dicoListeEquationAAfficher['initiation'])\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_propagation'),dicoListeEquationAAfficher['propagation'] )\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_termination'),dicoListeEquationAAfficher['termination'] )\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_creation','Chemical_Equation','b_ajout_equation','listeEquation_stabilization'),dicoListeEquationAAfficher['stabilization'] )\r
-    if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-\r
-    print ('fin recupereModeleEquation')\r
-    monMC.dsMaFunct = False\r
-    editor.dsMaFunct = False\r
-\r
-def ajoutDUneEquation(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur==False : return\r
-    editor=monMC.jdc.editor\r
-    prepareDiffusionSansMC(editor,monMC.nom)\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    editor.dsMaFunct = False\r
-    monMC.dsMaFunct = False\r
-\r
-def prepareDiffusion(monMC):\r
-    if monMC.valeur==False : return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    monMC.dsMaFunct=True\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    editor.dsMaFunct = True\r
-    print ('je suis dans prepareDiffusion', monMC.nom)\r
-    prepareDiffusionSansMC(editor,monMC.nom)\r
-    print ('fin de prepareDiffusion', monMC.nom)\r
-    monMC.dsMaFunct=False\r
-    editor.dsMaFunct = False\r
-\r
-def prepareDiffusionSansMC(editor,monMCNom):\r
-    lInitialBadCoche=editor.getValeur('Modele', 'Initial_Equation_List',('b_type_creation','Chemical_Equation'),)\r
-    lInitialCoche=[]\r
-    for equ in lInitialBadCoche: lInitialCoche.append(equ.split('\t')[0])\r
-    lInititiationCoche=editor.getValeur('Modele','listeEquation_initiation', ('b_type_creation','Chemical_Equation',))\r
-    lPropagationCoche =editor.getValeur('Modele', 'listeEquation_propagation',('b_type_creation','Chemical_Equation',))\r
-    lTerminationCoche=editor.getValeur('Modele','listeEquation_termination', ('b_type_creation','Chemical_Equation',))\r
-    lStabilizationCoche=editor.getValeur('Modele','listeEquation_stabilization', ('b_type_creation','Chemical_Equation',))\r
-\r
-    print (lInitialCoche,lInititiationCoche,lPropagationCoche,lTerminationCoche,lStabilizationCoche)\r
-    for liste in (lInitialCoche,lInititiationCoche,lPropagationCoche,lTerminationCoche,lStabilizationCoche):\r
-        # Il est possible qu'une liste soit vide lors de l initialisation\r
-        if liste == None : continue \r
-        for equation in liste :\r
-            print (equation)\r
-            for const in maClasseDelistesDB.dictParametresInitiaux[equation].constituants :\r
-              if const not in maClasseDelistesDB.listeParametresInitiaux : maClasseDelistesDB.listeParametresInitiaux.append(const)\r
-            #for coef in maClasseDelistesDB.dictParametresInitiaux[equation].const_cine_nom :\r
-            #  if coef not in maClasseDelistesDB.listeCoefInitiaux : maClasseDelistesDB.listeCoefInitiaux.append(coef)\r
-            for num,coef in enumerate(maClasseDelistesDB.dictParametresInitiaux[equation].const_cine_nom ):\r
-              maClasseDelistesDB.dicoCoefAffichageArr[coef]=maClasseDelistesDB.dictParametresInitiaux[equation].arrhenius[num]\r
-              if coef not in maClasseDelistesDB.listeCoefInitiaux : maClasseDelistesDB.listeCoefInitiaux.append(coef)\r
-\r
-    #print('maClasseDelistesDB.dictParametresInitiaux', maClasseDelistesDB.dictParametresInitiaux)\r
-    if monMCNom == 'Diffusion' :\r
-       change=editor.changeIntoDefMC('Modele', ('b_type_creation','Transport','b_diffusion','listeProduitPourLaDiffusion'), maClasseDelistesDB.listeParametresInitiaux )\r
-    if monMCNom == 'Evaporation' :\r
-       change=editor.changeIntoDefMC('Modele', ('b_type_creation','Transport','b_evaporation','listeProduitPourLEvaporation'), maClasseDelistesDB.listeParametresInitiaux )\r
-\r
-    if monMCNom in ('Evaporation','Diffusion') :\r
-       for c in list(monModele.coef[0].keys()) :\r
-        if c[0]=='D':\r
-           clef=c[1:]\r
-           if clef in maClasseDelistesDB.listeParametresInitiaux :\r
-              maClasseDelistesDB.listeCoefD.append(clef)\r
-              maClasseDelistesDB.listeCoefInitiaux.append('D'+clef)\r
-              maClasseDelistesDB.listeCoefInitiaux.append('S'+clef)\r
-           else :\r
-              maClasseDelistesDB.listeCoefASupprimer.append('S'+clef)\r
-              maClasseDelistesDB.listeCoefASupprimer.append('D'+clef)\r
-        if c[0]=='B':\r
-           clef=c[1:]\r
-           if clef in maClasseDelistesDB.listeParametresInitiaux :\r
-              maClasseDelistesDB.listeCoefB.append(clef)\r
-              maClasseDelistesDB.listeCoefInitiaux.append(c)\r
-           else :\r
-              maClasseDelistesDB.listeCoefASupprimer.append(c)\r
-    print ('aClasseDelistesDB.listeCoefB',maClasseDelistesDB.listeCoefB)\r
-    print ('aClasseDelistesDB.listeCoefB',maClasseDelistesDB.listeCoefD)\r
-    print ('maClasseDelistesDB.listeCoefInitiaux',maClasseDelistesDB.listeCoefInitiaux)\r
-    print ('maClasseDelistesDB.listeCoefASupprimer',maClasseDelistesDB.listeCoefASupprimer)\r
-    print ('maClasseDelistesDB.listeParametresInitiaux',maClasseDelistesDB.listeParametresInitiaux)\r
-    # au lieu des print il faut mettre a jour le MC Fact Coefficients avec ,maClasseDelistesDB.listeCoefInitiaux et le MC FACT\r
-    # Paraetres_initiaux avec maClasseDelistesDB.listeParametresInitiaux\r
-    # TO DO TO DO PNPN\r
-    # si on arrive avex\r
-    # if monMC.nom = Diffusion \r
-    if monMCNom == 'Diffusion' :\r
-      editor.setValeur('Modele','listeProduitPourLaDiffusion' ,maClasseDelistesDB.listeCoefD, ('b_type_creation','Transport','b_diffusion',))\r
-    #editor.changeValeur(....,'listeProduitPourLaDiffusion',maClasseDelistesDB.listeCoefD')\r
-    # if monMCNom == 'Evaporation' :\r
-    #editor.changeValeur(....,'listeProduitPourLaDiffusion',maClasseDelistesDB.listeCoefB')\r
-\r
-\r
-\r
-def ajouteEvaporation(monMC):\r
-    print ('je suis dans ajouteDiffusion')\r
-    if monMC.valeur == None : return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-\r
-    monMC.dsMaFunct=True\r
-    for v in monMC.valeur :\r
-        clef='B'+v\r
-        if clef not in maClasseDelistesDB.listeCoefInitiaux :\r
-              maClasseDelistesDB.listeCoefInitiaux.append(clef)\r
-\r
-    print ('sortie de ajouteDiffusion' , maClasseDelistesDB.listeCoefInitiaux)\r
-    monMC.dsMaFunct=False\r
-    editor.dsMaFunct = False\r
-\r
-def ajouteDiffusion(monMC):\r
-    print ('je suis dans ajouteDiffusion')\r
-    if monMC.valeur == None : return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-\r
-    monMC.dsMaFunct=True\r
-    for v in monMC.valeur :\r
-        clef='D'+v\r
-        if clef not in maClasseDelistesDB.listeCoefInitiaux :\r
-              maClasseDelistesDB.listeCoefInitiaux.append(clef)\r
-              maClasseDelistesDB.listeCoefInitiaux.append('S'+v)\r
-              maClasseDelistesDB.dicoCoefAffichageArr[clef] = True\r
-              maClasseDelistesDB.dicoCoefAffichageArr['S'+v] = False\r
-              #maClasseDelistesDB.dicoCoefAffichageArr['B'+v] = True\r
-        \r
-        # on affiche dans l interface  un mot clef avec clef comme nom et \r
-        # 2 reels si ce commence par D soit iniitialise a 0 si pas de valeur\r
-        # soit avec comme deifaut nomCoef in monModele.coef[0].keys()\r
-    print ('sortie de ajouteDiffusion' , maClasseDelistesDB.listeCoefInitiaux)\r
-\r
-    for nomCoef in maClasseDelistesDB.listeCoefInitiaux:\r
-        #A jout Ds Coef d'un MC \r
-        nomMC='Coef_'+nomCoef \r
-        if maClasseDelistesDB.dicoCoefAffichageArr[nomCoef]  == True:\r
-           print ('2 r'), \r
-           if nomCoef in monModele.coef[0].keys() :\r
-              print (monModele.coef[0][nomCoef])\r
-           else :\r
-              print ((0,0))\r
-        else :\r
-           print ('1 r') \r
-           if nomCoef in monModele.coef[0].keys() :\r
-              print (monModele.coef[0][nomCoef])\r
-           else :\r
-              print (0)\r
-\r
-    print ('______________________')\r
-    #for v in monMC.valeur :\r
-    #    print (v)\r
-    #    mesValeurs=editor.dicoCoefS[v]\r
-    #    MCFils='S'+v\r
-    #    for e in monMC.jdc.etapes:\r
-    #        if e.nom == 'Modele' :break\r
-    #    editor.ajoutDefinitionMC(e,('b_type_creation','b_diffusion'),MCFils,typ='TXM',statut='o' )\r
-    #    editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))\r
-    #    print ('______')\r
-    #if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-    monMC.dsMaFunct=False\r
-    editor.dsMaFunct = False\r
-\r
-\r
-# --------------------------------------------------------------------------------------------\r
-# pour les modeles en modification ou en utilisation\r
-# --------------------------------------------------------------------------------------------\r
-def creeListeMateriauxSelonModele(monMC):\r
-    if monMC.valeur == None : return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-\r
-    valeurDB=editor.getValeur('Modele','Modele_DB',())\r
-    maClasseDelistesDB.metAJour(valeurDB)\r
-    listModele=maClasseDelistesDB.getListModele()\r
-    listModeleFiltre=[]\r
-    listMateriauxFiltre=[]\r
-    for modele in listModele :\r
-        if modele.technical_use == monMC.valeur :\r
-           maClasseDelistesDB.dicoModeleFiltre[modele.nom]=modele\r
-           listModeleFiltre.append(modele.nom)\r
-           if type(modele.materiaux) not in (list, tuple): modeleATraiter= modele.materiaux\r
-           else : modeleATraiter= modele.materiaux[0]\r
-           if modeleATraiter not in listMateriauxFiltre :\r
-              listMateriauxFiltre.append(modeleATraiter)\r
-              maClasseDelistesDB.dicoMateriauxFiltre[modeleATraiter]=[modele.nom,]\r
-           else :\r
-              maClasseDelistesDB.dicoMateriauxFiltre[modeleATraiter].append(modele.nom)\r
- \r
-           \r
-\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_modification','b_technicalUse','material'),listMateriauxFiltre )\r
-\r
-    monMC.dsMaFunct=False\r
-    editor.dsMaFunct = False\r
-\r
-def creeListeModelesPossibles(monMC):\r
-    if monMC.valeur == None : return\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    editor=monMC.jdc.editor\r
-    if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return\r
-    change=editor.changeIntoDefMC('Modele', ('b_type_modification','b_technicalUse','modele'),maClasseDelistesDB.dicoMateriauxFiltre[monMC.valeur] )\r
-\r
-    monMC.dsMaFunct=False\r
-    editor.dsMaFunct = False\r
-\r
-def choisitModele(monMC):\r
-    # Equation b_modification modification\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    valeur=monMC.valeur\r
-    if valeur == None : return\r
-    modele=maClasseDelistesDB.dicoModeleFiltre[monMC.valeur]\r
-    maClasseDelistesDB.monModele=modele\r
-    monMC.dsMaFunct = False\r
-\r
-def choisitActionModele(monMC):\r
-    if monMC.valeur == 'display' : afficheModele(monMC)\r
-    if monMC.valeur == 'modify' : changeValeurDefautModele(monMC)\r
-\r
-def afficheModele(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    valeur=monMC.valeur\r
-    aAfficher=str(maClasseDelistesDB.monModele)\r
-    editor=monMC.jdc.editor\r
-    editor._viewText(aAfficher, "Id",largeur=700,hauteur=500)\r
-    \r
-    monMC.dsMaFunct = False\r
-              \r
-def changeValeurDefautModele(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    monMC.dsMaFunct = True\r
-    editor=monMC.jdc.editor\r
-    change=editor.changeIntoMCandSet('Modele', ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID','modeleName'),(maClasseDelistesDB.monModele.nom,),maClasseDelistesDB.monModele.nom, )\r
-    editor.setValeur('Modele','technicalUse',maClasseDelistesDB.monModele.technical_use, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-\r
-    editor.setValeur('Modele','material',maClasseDelistesDB.monModele.materiaux, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-    editor.setValeur('Modele','agingType',maClasseDelistesDB.monModele.type_vieil, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-\r
-    if maClasseDelistesDB.monModele.stabilise == 'True' : monBool = True\r
-    else : monBool = False\r
-    editor.setValeur('Modele','stabilizer',monBool, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-    editor.setValeur('Modele','material_thickness',maClasseDelistesDB.monModele.thickness, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-\r
-    if maClasseDelistesDB.monModele.dvt_EDF == 'True' : monBool = True\r
-    else : monBool = False\r
-    editor.setValeur('Modele','model_developed_by_for_EDF',monBool, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-    editor.setValeur('Modele','documentation',maClasseDelistesDB.monModele.reference, ('b_type_modification','b_technicalUse','b_modele','b_type_modify','ID'))\r
-    if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-    monMC.dsMaFunct = False\r
-\r
-\r
-\r
-def creeCoefAModifier(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur == None : return\r
-    monMC.dsMaFunct = True\r
-    editor=monMC.jdc.editor\r
-    dicoArr={}\r
-    dicoNonArr={}\r
-    for coef in maClasseDelistesDB.monModele.coef[0] :\r
-        if len (maClasseDelistesDB.monModele.coef[0][coef]) == 1 :\r
-               dicoNonArr[coef]=maClasseDelistesDB.monModele.coef[0][coef][0]\r
-        else :\r
-               dicoArr[coef]=maClasseDelistesDB.monModele.coef[0][coef]\r
-               if coef[0] == 'D' : maClasseDelistesDB.listeDiffusion.append(coef[1:])\r
-    print (dicoNonArr)\r
-    print (dicoArr)\r
-    if 'ri' in dicoNonArr :\r
-       print ('ajoutDefinitionMC debitOfDose')\r
-       editor.ajoutDefinitionMC('Modele', ('b_type_modification','b_technicalUse','b_modele','b_type_use2','Aging_Factor'), 'debitOfDose',typ='R',statut='o' )\r
-\r
-    for coef in dicoNonArr :\r
-        print (coef)\r
-        # attention, notation scientifique\r
-        editor.ajoutDefinitionMC('Modele',('b_type_modification','b_technicalUse','b_modele','b_type_use',),coef, 'R', statut='o',defaut=dicoNonArr[coef])\r
-        # a faire marcher\r
-        # pour les Arr il faut un tuple(2)\r
-       \r
-    # il fait creer un fact Boundary_Conditions_Param pour chacque espece de listeDiffusion\r
-   \r
-    if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()\r
-\r
-    monMC.dsMaFunct = False\r
-\r
-\r
-def remplirAgingFactor(monMC):\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur == None : return\r
-    monMC.dsMaFunct = True\r
-    editor=monMC.jdc.editor\r
-    if monMC.valeur in dicoAgingFactor:\r
-       print (monMC.valeur, 'trouve')\r
-       for MC in dicoAgingFactor[monMC.valeur]:\r
-           print (MC)\r
-           print (dicoAgingFactor[monMC.valeur][MC]),\r
-           editor.setValeur('Modele',MC,dicoAgingFactor[monMC.valeur][MC],('b_type_modification','b_technicalUse','b_modele','b_type_use2','Aging_Factor'))\r
-    monMC.dsMaFunct = False\r
-\r
-\r
-def creeInitialParameter(monMC):\r
-    print ('je passe dans creeInitialParameter')\r
-    if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return\r
-    if monMC.valeur == None : return\r
-    monMC.dsMaFunct = True\r
-    editor=monMC.jdc.editor\r
-    for coef in maClasseDelistesDB.monModele.param_ini:\r
-        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
-    monMC.dsMaFunct = False\r
-    # creer nbdenode = monMC.valeur Initial_Parameter\r
+import logging
+import types
+import os
+
+from mapy.virtual_polymer_common import class_data, pckdb
+from mapy.virtual_polymer_common import for_eficace 
+#database='/home/A96028/MAPVp/my_map_installdir/share/map/tests/components/c_pre_polymer_data_management/local/'
+database='/home/A96028/MAPVp/my_map_installdir/share/map/tests/components/c_pre_polymer_kinetics_study/local/'
+
+
+# --------------------------------------
+class sModele :
+# --------------------------------------
+
+   _instance = None
+
+   def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(sModele, cls).__new__(
+                                cls, *args, **kwargs)
+
+        return cls._instance
+
+   def __init__ (self):
+       self.dicoTU = {}
+       self.dicoTUForCreation = {}
+       self.valeurTUEnCours = None
+       self.valeurModeleNameEnCours = None 
+       self.dicoAnalytic = None
+       self.valeurEquationEnCours = None
+       self.valeurTUEnCoursForCreation = None
+
+monModele=sModele()
+
+
+# --------------------------------------
+# decorateur
+# --------------------------------------
+def entoure(func):
+    def wrapper( monMC):
+        if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return
+        editor=monMC.jdc.editor
+        monMC.dsMaFunct = True
+        retour =func(monMC,editor)
+        monMC.dsMaFunct = False
+    return wrapper    
+
+# --------------------------------------
+# MECHANISTIC
+# --------------------------------------
+
+# __________________ Creation ___________________
+@entoure
+def remplitChimicalKineticsMechanistic(monMC, editor) :
+     print ('in remplitChimicalKinetics')
+     etape=monMC.getEtape()
+     valeurModeleName=monMC.valeur
+     monModele.valeurModeleNameEnCours=valeurModeleName 
+     dico=monModele.dicoTU[monModele.valeurTUEnCours][valeurModeleName]
+     if 'debit_of_dose' in dico :
+        change = editor.ajoutMCinMCFactUnique(etape,'DebitOfDose', None ,('b_mechanistic','ChimicalKinetics'))
+     if 'initial_parameter' in dico :
+        valeurs=[]
+        for k in dico['initial_parameter'].keys():
+            # on prend la 1ere valeur 
+            valeurs.append((k,dico['initial_parameter'][k][0]))
+        change = editor.ajoutMCinMCFactUnique(etape,'InitialValue', valeurs ,('b_mechanistic','ChimicalKinetics'))
+     #dico['diffusion']=('O2','POOH')
+     # PNPN a developper
+     if 'diffusion' in dico and dico['diffusion'] != [] :
+        change = editor.ajoutMCFact(etape,'Boundary_Conditions_Param', ('b_mechanistic',))
+        #for produit in dico['diffusion'] :
+        # il faut ajouter les produits en tant que FACT et y mettre le nom
+  
+
+@entoure
+def remplitMechanisticModeleName(monMC, editor) :
+     print ('in remplitMechanisticModeleName')
+     etape=monMC.getEtape()
+     valeurTU=monMC.valeur
+     dico = for_eficace.filtre_calculation_mechanistic(database, valeurTU)
+     monModele.dicoTU[valeurTU]=dico
+     monModele.valeurTUEnCours=valeurTU
+
+     listeModeleName=list(dico.keys())
+     change = editor.changeIntoDefMC(etape,('b_mechanistic','ModeleName'),listeModeleName)
+
+
+
+# __________________ Modification  ___________________
+
+@entoure
+def remplitMechanisticModifyEquationListeEquation(monMC, editor):
+     print ('in remplitMechanisticModifyEquationListeEquation')
+     etape=monMC.getEtape()
+     valeurTU=monMC.valeur
+     print (valeurTU)
+     dico = for_eficace.filtre_calculation_mechanistic(database, valeurTU)
+     print (' --------------------')
+     print (database)
+     print (valeurTU)
+     print (dico)
+     print (' --------------------')
+     monModele.dicoTUForCreation[valeurTU]=dico
+     monModele.valeurTUEnCoursForCreation=valeurTU
+
+     listeEquation=list(dico.keys())
+     print (listeEquation)
+     change = editor.changeIntoDefMC(etape,('b_mechanistic','b_modify_equation','Filtre','Equation_List'),listeEquation)
+     print (change)
+
+
+@entoure
+def remplitModificationEquation(monMC, editor) :
+     print ('in remplitMechanisticModify')
+
+# --------------------------------------
+# ANALYTIC
+# --------------------------------------
+
+@entoure
+def remplitAnalyticModeleName(monMC,editor) :
+    print ('in prepareAnalytic')
+    etape=monMC.getEtape()
+    equationTy=monMC.valeur
+    dico = for_eficace.filtre_calculation_analitic(database, equationTy)
+    monModele.dicoAnalytic=dico
+    monModele.valeurEquationEnCours=equationTy
+
+    listeModeleName=list(dico.keys())
+    change = editor.changeIntoDefMC(etape,('b_analytic_model','ModeleName'),listeModeleName)
+
+@entoure
+def remplitChimicalKineticsAnalytic(monMC, editor) :
+     print ('in remplitChimicalKineticsAnalytic')
+     etape=monMC.getEtape()
+     valeurModeleName=monMC.valeur
+     monModele.valeurModeleNameEnCours=valeurModeleName
+     dico=monModele.dicoAnalytic[valeurModeleName]
+     if 'coef' in dico :
+        valeurs=[]
+        for k in dico['coef'].keys():
+            valeurs.append((k,float(dico['coef'][k])))
+        change = editor.ajoutMCinMCFactUnique(etape,'Coefficients', valeurs ,('b_analytic_model','ChimicalKinetics'))
+     #dico['diffusion']=('O2','POOH')
+
+
+
+#def filtre_calculation_mechanistic (dbdescription, technical_use):
+#def filtre_calculation_analitic (dbdescription, technical_use):
+#def filtre_data_model (dbdescription, physical,technical_use):
+#def analytic_equation_creaction():
+#
+if __name__=='__main__':
+     print ('in lienDB')

diff --git a/VirtualPolymer/prefs_VP.py b/VirtualPolymer/prefs_VP.py
index 33c5cfdc6dd1a22a49a3992645432bd9ea30c745..0d8010cebb251947a0c6c9ddf1401a2129ed1929 100644 (file)
--- a/VirtualPolymer/prefs_VP.py
+++ b/VirtualPolymer/prefs_VP.py
@@ -43,3 +43,4 @@ closeEntete = True
 #closeArbre = True
 afficheOptionnelVide=False
 
+#### il faut afficher les listes pliees