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