def UQPossible(self):
# Plus facile de mettre cette methode dans le SIMP, car on connait son nom
+ # reflechir au TUI
if not hasattr(self.cata,'dictUQ') : return False
- if self.nom in self.cata.dictUQ.keys() : return True
- return False
+ if not (self.nom in self.cata.dictUQ.keys()) : return False
+ if not hasattr(self.cata,'dictUQConditions') : return True
+ if not (self.nom in self.cata.dictUQConditions.keys()) : return True
+ maFonction = self.cata.dictUQConditions[self.nom][0]
+ argsLoi = self.cata.dictUQConditions[self.nom][1]
+ argsLoi['obj'] = self
+ return maFonction(**argsLoi)
def isUQActivate(self):
# valide uniquement pour les MCSIMP
def delieVariableUQ(self):
+ print ('uuuuuuuuuuuuuuuu', self.nom)
self.associeVariableUQ=False
# Attention, on n a pas le MCLIST mais le MCLIST(0) dans la variableProbabiliste
# si self est le seul alors on enleve la MCLIST du MCCOMPO
for vp in mcVP :
vp.variableDeterministe.variableProbabilite=None
vp.variableDeterministe.associeVariableUQ=False
+ vp.variableDeterministe.definition.siValide=None
#ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
def buildSd(self):
@param coord the position of the mouse pointer (QPoint)
Attention : existeMenu permet de savoir si un menu est associe a cet item
"""
- print ("handleContextMenu")
+ #print ("handleContextMenu")
if item == None : return
self.itemCourant = item
if item.existeMenu == 0 : return
#if item.nom == 'ExpressionIncertitude':
# print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
-
self.item = item
self.vraiParent = treeParent
self.treeParent = treeParent
""" Construit la liste des enfants de self """
""" Se charge de remettre les noeuds Expanded dans le meme etat """
#print ("*********** buildChildren ",self,self.item, self.item.nom)
+ #if self.item.nom == 'Scenario_data' : print ("*********** buildChildren ",self.item.nom)
+ #if self.item.nom == 'test.comm' :
+ # print ("1111 *********** buildChildren ",self.item.nom,)
+ # for c in self.children:
+ # if (c.item.nom == 'Scenario_data') :
+ # print (c)
+ # print (c.item)
+ # print (c.item.nom)
+
+ #if self.item.nom == 'Scenario_data' :
+ # import traceback
+ # traceback.print_stack()
#print (poum)
self.listeItemExpanded=[]
if item in self.listeItemPlie : itemExpand=False; ancien=True
nouvelItem=item.itemNode(self,item,itemExpand,ancien)
self.children.append(nouvelItem)
+
- #print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
+ #if self.item.nom == 'test.comm' :
+ # print ("fin *********** buildChildren ",self.item.nom,)
+ # for c in self.children:
+ # if (c.item.nom == 'Scenario_data') :
+ # print (c)
+ # print (c.item)
+ # print (c.item.nom)
+ #if self.item.nom == 'Scenario_data' : print ("*********** buildChildren ",sublist)
+ #if self.item.nom == 'Scenario_data' : print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
def chercheNoeudCorrespondant(self,objSimp):
self.editor.widgetCentraleLayout.removeItem(widget)
# ceinture et bretelle
- #print 'old fenetre = ',self.editor.fenetreCentraleAffichee
+ #print ('old fenetre = ',self.editor.fenetreCentraleAffichee)
+ #try :
+ #print ('old fenetre nom = ',self.editor.fenetreCentraleAffichee.item.nom)
+ #except : pass
if self.editor.fenetreCentraleAffichee != None :
try :
self.editor.widgetCentraleLayout.removeWidget(self.editor.fenetreCentraleAffichee)
self.editor.fenetreCentraleAffichee.setParent(None)
self.editor.fenetreCentraleAffichee.close()
self.editor.fenetreCentraleAffichee.deleteLater()
+ #print ('en sortie du try sur la vieille fenetre')
except :
pass
self.editor.widgetCentraleLayout.addWidget(self.fenetre)
- #print ("j ajoute ", self.fenetre, self.fenetre.node.item.nom)
self.editor.fenetreCentraleAffichee=self.fenetre
self.tree.node_selected= self
#print ("onAdd pour ", self.item.nom, object)
if self.JESUISOFF == 1 : return
self.editor.initModif()
- self.updateNodes()
+ self.buildChildren()
if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
def onSupp(self,object):
#-----------------------
- #print ("onSup pour ", self.item.nom, object)
- #import traceback
- #traceback.print_stack()
+ import traceback
+ #if self.item.nom == 'Scenario_data' : traceback.print_stack()
if self.JESUISOFF==1 : return
+ #print ("onSup 2 pour ", self.item.nom, self.item.node)
self.editor.initModif()
- self.updateNodes()
+ self.buildChildren()
if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
def onRedessine(self):
#---------------------
- #print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!je passe dans onRedessine pour', self.item.nom)
self.affichePanneau()
def updateNodeValid(self):
def updateNodes(self):
#--------------------------------
+ print (' appeler buildChildren dircetement serait mieux')
#print 'NODE updateNodes', self.item.getLabelText()
self.buildChildren()
except : pass
import types,sys,os, re
-import subprocess
+import subprocess
import traceback
# ---------------------------------------------
# _newJDC
# _newJDCInclude
-# __generateTempFilename
+# generateTempFilename
# getSource
# generDico
# viewJdcSource
noeudAvantCommentaire.addComment(True)
- #---------------------------------------------------------------#
- def _viewTextExecute(self, txt, prefix, suffix, fichierExe=None):
- #---------------------------------------------------------------#
+ #----------------------------------------------------------------------------#
+ def _viewTextExecute(self, txt, prefix, suffix, fichierExe=None, shell='sh'):
+ #---------------------------------------------------------------------------#
self.w = ViewText( self.QWParent )
self.w.setWindowTitle( "execution" )
self.monExe=QProcess(self.w)
pid=self.monExe.pid()
if not fichierExe :
- fichierExe = self.__generateTempFilename(prefix, suffix = ".sh")
- f=open(fichierTemp,'w')
+ fichierExe = self.generateTempFilename(prefix, suffix = ".sh")
+ f=open(fichierExe,'w')
f.write(txt)
f.close()
self.monExe.readyReadStandardOutput.connect( self.readFromStdOut)
self.monExe.readyReadStandardError.connect( self.readFromStdErr)
- exe='sh ' + fichierExe
+ exe=shell + ' ' + fichierExe
self.monExe.start(exe)
self.monExe.closeWriteChannel()
self.w.exec_()
- try:
+ if self.monExe!=None:
+ self.monExe.readyReadStandardOutput.disconnect()
+ self.monExe.readyReadStandardError.disconnect()
+ if txt:
commande="rm "+ fichierExe
os.system(commande)
- except :
- pass
return 1
def readFromStdErr(self):
a=self.monExe.readAllStandardError()
- self.w.view.append(str(a.data()))
+ chaine = str(a.data(), encoding="utf-8").rstrip()
+ self.w.view.append(chaine)
+ #self.w.view.append(str(a.data()))
def readFromStdOut(self) :
a=self.monExe.readAllStandardOutput()
- self.w.view.append(str(a.data()))
+ chaine = str(a.data(), encoding="utf-8").rstrip()
+ self.w.view.append(chaine)
+ # self.w.view.append(str(a.data()))
#-----------------------#
QMessageBox.critical( self, tr("Execution impossible "),tr("le JDC doit contenir un et un seul composant"))
return
if self.modified or self.fichier==None :
- self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
+ self.fichierMapInput = self.generateTempFilename(prefix = "map_run", suffix = ".map")
texte=self.getTextJDC("MAP")
self.writeFile( self.fichierMapInput, txt = texte)
else :
return
if self.modified or self.fichier==None :
#if 1:
- self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
+ self.fichierZcracksInput = self.generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
texte=self.getTextJDC("ZCRACKS",pourRun=1)
self.writeFile( self.fichierZcracksInput, txt = texte)
else :
repMed=os.path.dirname(self.fichier)
repExeCarmel=self.generator.get_repExeCarmel()
textePython=prepareRunCarmel(repExeCarmel,repMed,fichierGenerique)
- nomFichier = self.__generateTempFilename("carmel_run", suffix = ".sh")
+ nomFichier = self.generateTempFilename("carmel_run", suffix = ".sh")
f=open(nomFichier,'w')
f.write(textePython)
f.close()
self.monNomFichierInput=fn
if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
- self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
+ self.fichierMapInput = self.generateTempFilename(prefix = "map_run", suffix = ".map")
texte=self.getTextJDC("MAP")
self.writeFile( self.fichierMapInput, txt = texte)
if self.appliEficas.salome : self.appliEficas.close()
else : sys.exit(1)
- if not JDCEditorSsIhm.saveUQFile (self,fn):
- msgBox = QMessageBox(None)
- titre = 'Probleme de sauvegarde fichier UQ'
- texte = 'Impossible de sauvegarder {}'.format(fn)
- QMessageBox.information( self, titre,texte)
+ ret,comm = JDCEditorSsIhm.saveUQFile (self,fn)
+ if not ret :
+ if comm :
+ msgBox = QMessageBox(None)
+ titre = 'Probleme de sauvegarde fichier UQ'
+ texte = 'Impossible de sauvegarder {}'.format(fn)
+ QMessageBox.information( self, titre,texte)
+ return (0,self.fichier)
return (1, self.fichier)
#-----------------------------------------------#
def exeUQ(self, fichier = None, path =None):
#------------------------------------------------#
- if self.modified or not self.fichier :
- sauvegarde, fichier= self.saveUQFile()
- if not sauvegarde : return 0
- print ('je suis la')
- print ('je suis la')
- print ('je suis la')
- directoryExe='/tmp'
- self._viewTextExecute(None,None,None, fichierExe='/home/A96028/QT5Dev/eficasRN/ReacteurNumerique/test.sh')
- return (1, directoryExe)
+ #if self.modified or not self.fichier :
+ sauvegarde, fichier= self.saveUQFile()
+ if not sauvegarde : return 0
+ #self._viewTextExecute(None,None,None, fichierExe=self.generator.fichierUQExe, shell='python3')
+ #self._viewTextExecute('ls -l /tmp','essaiLs','.sh',)
+ self._viewTextExecute(None,None,None, fichierExe='/home/A96028/QT5Dev/eficasRN/ReacteurNumerique/a.py',shell='python3',)
+ return True
#----------------------------------------------#
def sauveLigneFile(self):
return None
#----------------------------------------------#
- def __generateTempFilename(self, prefix, suffix):
+ def generateTempFilename(self, prefix, suffix):
#----------------------------------------------#
import tempfile
(fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
return 0, None
self.fichier=fichier
self.generator=generator.plugins['UQ']()
- ret = self.generator.creeNomsFichiers(fichier)
+ ret,comm = self.generator.creeNomsFichiers(fichier)
if not ret :
self.informe('Sauvegarde UQ', self.generator.commentaire)
return ret, None
self.avantH=self.editor.fenetreCentraleAffichee.scrollAreaCommandes.horizontalScrollBar().sliderPosition()
self.avantV=self.editor.fenetreCentraleAffichee.scrollAreaCommandes.verticalScrollBar().sliderPosition()
self.inhibeExpand=True
- self.node.affichePanneau()
+ # Attention : lorsqu'on reconstruit l arbre au milieu par une fonction siValide (exemple dans UQ)
+ # alors self.node.item.node est different de self.node
+ # il faut regarder si la Widget utililse self.node a d autres endroits
+ self.node.item.node.affichePanneau()
#QTimer.singleShot(1, self.recentre)
if nodeAVoir != None and nodeAVoir!=0:
self.f=nodeAVoir.fenetre
AppliSsIhm.ajoutUQ(self)
self.menuUQ = self.menubar.addMenu(tr("Incertitude"))
self.actionSaveUQ = QAction(self)
- self.actionSaveUQ.setText(tr("Sauvegarde des fichiers pour l etude incertaine"))
+ self.actionSaveUQ.setText(tr("Sauvegarde des fichiers pour l'étude incertaine"))
self.menuUQ.addAction(self.actionSaveUQ)
self.actionSaveUQ.triggered.connect(self.handleSortieUQ)
self.actionExeUQ = QAction(self)
- #self.actionExeUQ.setText(tr("Lancement de l etude"))
- #self.menuUQ.addAction(self.actionExeUQ)
- #self.actionExeUQ.triggered.connect(self.handleExeUQ)
- #self.actionEnregistrer.setDisabled(True)
- #self.actionEnregistrer_sous.setDisabled(True)
+ self.actionExeUQ.setText(tr("Sauvegarde et Lancement de l'étude"))
+ self.menuUQ.addAction(self.actionExeUQ)
+ self.actionExeUQ.triggered.connect(self.handleExeUQ)
+ self.actionEnregistrer.setDisabled(True)
+ self.actionEnregistrer_sous.setDisabled(True)
def ajoutN1(self):
return
# incertitude --> change le convert
if hasattr(self.cata, 'avecIncertitude') : self.appliEficas.ajoutUQ()
+ if hasattr(self.cata, 'modifieCatalogueDeterministe') : self.cata.modifieCatalogueDeterministe(self.cata)
def importCata(self,cata):
"""
import os, sys
repInitial = os.path.dirname(os.path.abspath(__file__))
-repEficas = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if os.path.dirname(repInitial) not in sys.path :
- sys.path.insert(0,repInitial)
-if os.path.dirname(repEficas) not in sys.path :
- sys.path.insert(0,repEficas)
+repEficas = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if os.path.dirname(repInitial) not in sys.path : sys.path.insert(0,repInitial)
+if os.path.dirname(repEficas) not in sys.path : sys.path.insert(0,repEficas)
import types
-#from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, Matrice, Tuple, AU_MOINS_UN, A_VALIDATOR, PROC
from Noyau.N_VALIDATOR import Valid
-
-# #autonome=1
-# autonome=0
-# if autonome :
-# from Accas import *
-# #from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, Matrice, Tuple, AU_MOINS_UN, A_VALIDATOR, PROC
-# JdC = JDC_CATA(code="UQ");
-# ExpressionIncertitude = creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles);
-# else:
from cata_RN import *
# sert a activer les options d incertitude dans eficas
# et a changer le convert en convertUQ
+
+def supprimeExpressionIncertitude(obj):
+ if not (hasattr(obj, 'oldValue')) :
+ obj.oldValue=obj.valeur
+ return
+ if obj.oldValue==obj.valeur : return
+ obj.oldValue=obj.valeur
+ jdc=obj.getJdcRoot()
+ etapesUQ=obj.jdc.getEtapesByName('ExpressionIncertitude')
+ for e in etapesUQ : # a priori une seule
+ jdc.suppEntite(e)
+
+def maFonctionDeModif(cata) :
+ scenario_type=cata.Scenario_data.entites['scenario_type']
+ scenario_type.changeSiValide(supprimeExpressionIncertitude)
+
avecIncertitude=True
-#
-dictUQ = {'initial_power' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}, {'UserDefined' :{}}),
- 'initial_core_inlet_temperature' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
- 'initial_boron_concentration' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
- 'initial_inlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
- 'initial_outlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
- 'assembly_width' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
+modifieCatalogueDeterministe=maFonctionDeModif
+
+def scenarioEgal(valeursPossibles, obj ):
+ listeEtapeScenario=obj.jdc.getEtapesByName('Scenario_data')
+ if len(listeEtapeScenario) !=1 : return False
+ else : etapeScenario=listeEtapeScenario[0]
+ scenario_type=etapeScenario.getChildOrChildInBloc('scenario_type')
+ if scenario_type.valeur == None : return False
+ if scenario_type.valeur in valeursPossibles : return True
+ return False
+
+dictUQConditions = {'initial_power' : (scenarioEgal, {'valeursPossibles':('HLO', 'RIA')}),
+ 'initial_core_inlet_temperature' : (scenarioEgal, {'valeursPossibles':('RIA')}),
+ 'initial_boron_concentration' : (scenarioEgal, {'valeursPossibles':('RIA')}),
+ 'initial_inlet_pressure' : (scenarioEgal, {'valeursPossibles':('RIA')}),
+ 'initial_outlet_pressure' : (scenarioEgal, {'valeursPossibles':('RIA')}),
+ 'assembly_width' : (scenarioEgal, {'valeursPossibles':('RIA')}),
+ }
+
+# Creation des lois :
+# clef : variable deterministe
+# valeur : dico des lois possibles ou le dictionnaire contient les parametres de creation de la loi
+# il faudra eventuellement revoir ce mecanisme si on decide d affiner par scenario ces parametres
+# cela pourrait se faire soit avec des blocs lors de la creation des lois
+# ou par activation de fonctions de changement dynamique des SIMP ( comme changeIntoSelonValeurs)
+dictUQ = {'initial_power' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}, {'UserDefined' :{}}),
+ 'initial_core_inlet_temperature' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
+ 'initial_boron_concentration' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
+ 'initial_inlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
+ 'initial_outlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
+ 'assembly_width' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}),
# modifier la partie Accas pour garder une reference a l objet nomme
}
-listeDesSortiesNeutro = ( "Boron concentration", "Kinetic reactivity", "Neutronic power", )
-listeDesSortiesThermo = ("Average mass flux", "Boiling power fraction", "Enthalpy", "Fuel temperature", "Liquid power", "Mass flux", "Mass fraction", "Mass title", "Mixture density", "Mixture specific enthalpy", "Mixture temperature", "Outlet pressure", "Pollutant concentration", "Pressure ", "Rowlands fuel effective temp", "Thermal power", "Water density", "Water temperature", )
+listeDesSortiesNeutro = ("Boron concentration", "Kinetic reactivity", "Neutronic power",)
+listeDesSortiesThermo = ("Average mass flux", "Boiling power fraction", "Enthalpy", "Fuel temperature",\
+ "Liquid power", "Mass flux", "Mass fraction", "Mass title", "Mixture density", \
+ "Mixture specific enthalpy", "Mixture temperature", "Outlet pressure", "Pollutant concentration", \
+ "Pressure ", "Rowlands fuel effective temp", "Thermal power", "Water density", "Water temperature", )
scriptPosttraitement = os.path.join(repEficas,"generator","post_csv_rn.py")
-scriptDeLancement = os.path.join(repInitial,"ib_test.sh")
-dicoDesSortiesPossibles={'Neutronics':listeDesSortiesNeutro,'Thermalhydraulics':listeDesSortiesThermo}
-#dicoDesSortiesPossibles={'Thermalhydraulics':listeDesSortiesThermo}
-from cata_UQ import creeOperExpressionIncertitude
-ExpressionIncertitude=creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles, scriptPosttraitement, scriptDeLancement)
+scriptDeLancement = os.path.join(repInitial,"ib_test.sh")
+dicoDesSortiesPossibles = {'Neutronics':listeDesSortiesNeutro,'Thermalhydraulics':listeDesSortiesThermo}
+from cata_UQ import creeOperExpressionIncertitude
+ExpressionIncertitude = creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles, scriptPosttraitement, scriptDeLancement)
