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
11 monDico= { 'Equation_Liste' : ('initiation', 'propagation', 'termination', 'stabilization'),
\r
12 'Modele_TechnicalUse' : ('cable', 'coating', 'pipes'),
\r
16 def __init__(self,ntuple):
\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
25 return "Tuple de %s elements" % self.ntuple
\r
30 #class ObjetUtilisateur(ASSD): pass
\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
41 return ('a1','a2','a3')
\r
43 def maFuncWithArg(monMC):
\r
44 if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return
\r
45 monMC.dsMaFunct = True
\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
51 change=editor.changeIntoDefMC('AGING', ('Equation', 'b_approved','b_type_creation','Equation_Modification','Type2'), monInto )
\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
57 monMC.dsMaFunct = False
\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
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
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
82 listeEquationPourIhm = []
\r
83 listeReprEquationPourIhm = []
\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
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
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
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
110 editor.maClasseVisuEquation.valeurEquationChoisie=valeur
\r
111 monMC.dsMaFunct = False
\r
114 def instancieChemicalFormulation(monMC):
\r
115 if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return
\r
116 if monMC.valeur == False : return
\r
118 editor=monMC.jdc.editor
\r
119 if hasattr(editor,'dsMaFunct') and editor.dsMaFunct== True : return
\r
120 editor.dsMaFunct = True
\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
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
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
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
152 if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()
\r
153 monMC.dsMaFunct = False
\r
154 editor.dsMaFunct = False
\r
161 maClasseDeModele=class_data.Modele()
\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
173 def creeListeEquation(monMC):
\r
174 if monMC.valeur == None: return
\r
175 if hasattr(monMC,'dsMaFunct') and monMC.dsMaFunct== True : return
\r
177 editor=monMC.jdc.editor
\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
187 monMC.dsMaFunct = False
\r
189 # listeEquation_stabilization=SIMP(statut='o', homo='SansOrdreNiDoublon', max='**', min=0 ),
\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
197 editor.dsMaFunct = True
\r
198 dicoListeEquationAAfficher={}
\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
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
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
227 valeur= maClasseDeModele.coef[0][c]
\r
228 editor.dicoCoefS[clef]=valeur
\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
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
249 for v in monMC.valeur :
\r
251 mesValeurs=editor.dicoCoefS[v]
\r
252 print (editor.dicoCoefS)
\r
255 for e in monMC.jdc.etapes:
\r
256 if e.nom == Modele :break
\r
259 editor.ajoutDefinitionMC(e,('b_type_creation','b_diffusion'),MCFils,typ='TXM',statut='o' )
\r
261 editor.ajoutMC(e,MCFils,mesValeurs,('b_type_creation','b_diffusion',))
\r
263 if editor.fenetreCentraleAffichee : editor.fenetreCentraleAffichee.node.affichePanneau()
\r
264 monMC.dsMaFunct=False
\r
265 editor.dsMaFunct = False
\r
267 JdC = JDC_CATA(code='VP',
\r
273 #---------------------------------
\r
274 Equation = PROC (nom="Equation",
\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
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
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
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
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
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
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
314 ), # fin b_modification
\r
315 ), # Fin b_type_show
\r
318 # ---------------------------------------------------------------------------
\r
319 b_type_creation = BLOC(condition = " Equation_Type == 'Equation creation'",
\r
320 # ---------------------------------------------------------------------------
\r
321 Equation_Modification = FACT ( statut = 'o',
\r
323 ChemicalFormulation = SIMP(statut='o', typ='TXM', defaut = 'POOH -> 2P'),
\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
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
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
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
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
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
353 Commentaire = SIMP (statut = 'f', typ = 'TXM', defaut = ' '),
\r
355 ), # Fin Equation_Modification
\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
361 ), # fin b_type_creation
\r
366 #---------------------------------
\r
367 Modele = PROC (nom="Modele",
\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
381 # ajouter la liste des equations et le remove (il faut garder ceux qu on a enlever)
\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
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
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
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
405 ), # fin b_type_creation
\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
412 Commentaire = SIMP (statut = 'f', typ = 'TXM'),
\r