return mcs
#
- def UQPossible(self):
- return True
"""
return tr(self.nom)
- def getListeMcOrdonnee(self,liste,dico):
+ def getListeMcOrdonnee(self,liste,dico,avecCache=True):
"""
Retourne la liste ordonnee (suivant le catalogue) des mots-cles
d'une entite composee dont le chemin complet est donne sous forme
il faut encore rearranger cette liste (certains mots-cles deja
presents ne doivent plus etre proposes, regles ...)
"""
- return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico))
+ return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico,avecCache=avecCache))
def getListeMcOrdonneeBrute(self,liste,dico):
"""
if specifique == 1 : return l
return objet_cata.ordre_mc
- def filtreListeMc(self,liste_brute):
+ def filtreListeMc(self,liste_brute,avecCache=True):
"""
Cette methode est appelee par EFICAS afin de presenter a
l'utilisateur la liste des enfants possibles de self actualisee
liste des possibles (fournie par la definition), les mots-cles
exclus par les regles de self et les mots-cles ne pouvant plus
etre repetes
+ si avecCache=False on n inclut pas les MC dont le statut = cache
"""
liste = copy(liste_brute)
listeMcPresents = self.listeMcPresents()
# un mot-cle facteur ne peut pas etre repete plus de self.max fois
if objet.definition.max == 1:
liste.remove(k)
+ if not avecCache and objet.definition.statut in ('c','d','cache'): liste.remove(k)
elif isinstance(objet,MCList):
try :
nb_occur_maxi = objet[0].definition.max
if len(objet) >= nb_occur_maxi:
liste.remove(k)
+ if not avecCache and objet[0].definition.statut=='cache': liste.remove(k)
except:
pass
else :
if CONTEXT.debug : print(' ',k,' est un objet de type inconnu :',type(objet))
else :
# l'objet est absent : on enleve de la liste les blocs
- if self.definition.entites[k].statut=='c' :
+ if self.definition.entites[k].statut=='c' or self.definition.entites[k].statut=='cache' :
liste.remove(k)
if self.definition.entites[k].label=='BLOC':
liste.remove(k)
# un mot-cle facteur ne peut pas etre repete plus de self.max fois
if objet.definition.max > 1:
liste.append(k)
+ if not avecCache and objet.definition.statut=='cache': liste.remove(k)
elif isinstance(objet,MCList):
nb_occur_maxi = objet[0].definition.max
if len(objet) < nb_occur_maxi:
liste.append(k)
+ if not avecCache and objet[0].definition.statut=='cache': liste.remove(k)
return liste
def listeMcPresents(self):
leMotCle.demandeRedessine()
print ('fin updateAutresMotsClefs')
+
+ def UQPossible(self):
+ # Plus facile de mettre cette methode dans le SIMP, car on connait son nom
+ if not hasattr(self.cata,'dictUQ') : return False
+ if self.nom in self.cata.dictUQ.keys() : return True
+ return False
+
+ def isUQActivate(self):
+ # valide uniquement pour les MCSIMP
+ # a reflechir a la relecture du .comm
+ return False
+
+
#print ('demandeRedessine pour', self.nom, self, tout)
CONNECTOR.Emit(self,"redessine")
- def isUQActivate(self):
- # valide uniquement pour les MCSIMP
- return True
+ def ajouteAuxIncertains(self):
+
+ etapeIncertitude=self.jdc.getEtapesByName('ExpressionIncertitude')
+ if etapeIncertitude == [] :
+ self.jdc.editor.tree.racine.appendChild('ExpressionIncertitude', 'last')
+ etapeIncertitude=self.jdc.getEtapesByName('ExpressionIncertitude')
+ etapeIncertitude=etapeIncertitude[0]
+ incertitudeInput = etapeIncertitude.getChildOrChildInBloc('Input')
+ nodeVariableProbabiliste=incertitudeInput.node.appendChild('VariableProbabiliste', 'first')
+ # le buildChildren a une mcliste --> on est oblige de mettre first mais en fait c est last
+ if nodeVariableProbabiliste.item.object.nature=='MCFACT' :
+ newVariable=nodeVariableProbabiliste.item.object
+ else :
+ newVariable=nodeVariableProbabiliste.item.object[-1]
+ newVariable.variableDeterministe = self
+
+ itemModelVariable=newVariable.getChild('ModelVariable')
+ itemModelVariable.setValeur(self.nom)
+
+ itemConsigne=newVariable.getChild('Consigne')
+ itemConsigne.setValeur('la valeur entrée pour {} est {}'.format(self.nom, self.valeur))
+
+ itemXPath=newVariable.getChild('xPathVariable')
+ #itemXPath.reparent(newVariable)
+ itemXPath.setValeur(self.getGenealogiePrecise())
+ #print (itemXPath)
+
+ self.variableProbabiliste=nodeVariableProbabiliste.item
+ self.definition.siValide = self.changeValeursRefUQ
+
+ def changeValeursRefUQ (self, motClef):
+ if not hasattr(motClef,'variableProbabiliste') : print ('pb ds changeValeursRefUQ'); return
+ itemConsigne=motClef.variableProbabiliste.getChild('Consigne')
+ itemConsigne.setValeur('la valeur entrée pour {} est {}'.format(motClef.nom, motClef.valeur))
+ motClef.variableProbabiliste.valeurProbabiliste=motClef.valeur
+
+ def enleveDesIncertains(self):
+ print ('pas encore programme')
class ErrorObj(OBJECT):pass
def handleOnItem(self,item,int):
#----------------------------------
- #print ("je passe dans handleOnItem pour ",self, item.item.nom, item, item.item, item.item.getLabelText())
+ print ("je passe dans handleOnItem pour ",self, item.item.nom, item, item.item, item.item.getLabelText())
from InterfaceQT4 import composimp
self.inhibeExpand = True
#----------------------------------------------------------------------
#print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
#self.a=0
+ #if item.nom == 'ExpressionIncertitude':
+ # print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
self.item = item
self.JESUISOFF = 0
self.firstAffiche = True
self.childrenComplete=[]
+ self.item._object.node = self
from InterfaceQT4 import compocomm
self.treeParent.childrenComplete.append(self)
- if (isinstance(self,compobloc.Node) or (isinstance(self,compomclist.Node) and self.item.isMCList()) or ( hasattr(self.item.parent,'inhibeValidator') and isinstance(self,compomclist.Node) and self.item.parent.inhibeValidator)) :
+ if (isinstance(self,compobloc.Node) or (isinstance(self,compomclist.Node) and self.item.isMCList()) or ( hasattr(self.item.parent,'inhibeValidator') and isinstance(self,compomclist.Node) and self.item.parent.inhibeValidator) or (isinstance(self,composimp.Node) and self.item.definition.statut in ('c','d'))) :
# Le dernier or ne sert que lorsqu'on est en train de creer une liste par les validator
QTreeWidgetItem.__init__(self,None,mesColonnes)
else :
Si pos vaut None, on le place a la position du catalogue.
"""
#print ("************** appendChild ",self.item.getLabelText(), pos, plier)
- #import traceback
- #traceback.print_stack()
-
self.editor.initModif()
if pos == 'first' : index = 0
monObjet=self.item.object
monNom=self.item.nom
+ # le mot clef est cache ou cache avec defaut
+ if maDefinition.statut in ('c','d') : return None
+
# label informatif
if monObjet.isInformation():
from InterfaceQT4.monWidgetInfo import MonWidgetInfo
self.withXSD=False
self.afficheIhm=True
- self.afficheUQ=False
- #self.afficheUQ=True
+ #self.afficheUQ=False
+ self.afficheUQ=True
self.appliEficas.setWindowTitle(nouveauTitre)
return (1, self.fichier)
-#
+
+ #-----------------------------------------------#
+ def saveUQFile(self, fichier = None, path =None):
+ #------------------------------------------------#
+ if self.fichier is None :
+ if path is None: path=self.maConfiguration.savedir
+ bOK, fn=self.determineNomFichier(path,'comm')
+ if bOK == 0 : return (0, None)
+ if fn == None : return (0, None)
+ if fn== '' : return (0, None)
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
+ fn = QDir.toNativeSeparators(fn)
+ else : fn = self.fichier
+
+ if self.jdc.isValid() == 0 :
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier invalide / incomplet"))
+ msgBox.setText(tr("Le fichier .comm est invalide / incomplet"))
+ msgBox.addButton(tr("&Sauvegarder le .comm"),0)
+ msgBox.addButton(tr("&Quitter sans sauvegarder"),1)
+ msgBox.addButton(tr("&Annuler"),2)
+ res=msgBox.exec_()
+ if res == 2 : return (0, None)
+ if res == 0 :
+ ret, fichier = JDCEditorSsIhm.saveFile (self,fn)
+ if ret : self.fichier = fichier
+ if self.salome and ret:
+ self.appliEficas.addJdcInSalome( self.fichier)
+ return (1, self.fichier)
+ 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)
+ return (1, self.fichier)
#----------------------------------------------#
def sauveLigneFile(self):
#-----------------------------------------------------------------#
fn = fichier
self.generator=generator.plugins[self.format]()
- print (self.generator)
+ #print (self.generator)
if hasattr(self.generator, "writeComplet"):
self.generator.writeComplet(fichier,self.jdc,config=self.appliEficas.maConfiguration,appliEficas=self.appliEficas)
+ #-----------------------------------#
+ def saveUQFile(self, fichier = None):
+ #------------------------------------#
+ if fichier == None : print ("nom de fichier obligatoire pour sauvegarde"); return
+ self.generator=generator.plugins['UQ']()
+ ret = self.generator.gener(self.jdc)
+ if not ret :
+ self.informe('Sauvegarde UQ', self.generator.commentaire)
+ return (ret, self.generator.commentaire)
+ self.fichier=fichier
+ ret = self.generator.writeUQ(fichier)
+ if not ret : self.informe('Sauvegarde UQ', self.generator.commentaire)
+ print ('ok')
+ return ret
# ---------------------------------------------
# Methodes Surchargees par avecIhm
if code != None : options.code = code
if options.fichierCata == None :
print ('Use -c cata_name.py')
- return
+ return 1
fichier=options.comm[0]
if fichier==None :
print ('comm file is needed')
- return
+ return 1
from .editorSsIhm import JDCEditorSsIhm
monEficasSsIhm = getEficasSsIhm(code=options.code)
monEditeur=JDCEditorSsIhm(monEficasSsIhm,fichier)
self.setZoneInfo()
self.setUnite()
#inhibition incertitude
- if hasattr(self,'checkBoxUQ') : self.checkBoxUQ.close()
+ #if hasattr(self,'checkBoxUQ') : self.checkBoxUQ.close()
+ self.setUQ()
def setUnite(self):
if not (self.editor.appliEficas.maConfiguration.afficheUQ) and hasattr(self,'checkBoxUQ') :
self.checkBoxUQ.close()
return
- if not self.monSimpDef.UQPossible():
+ if not self.objSimp.UQPossible() and hasattr(self,'checkBoxUQ'):
self.checkBoxUQ.close()
return
+ if not self.objSimp.UQPossible() : return
+ self.checkBoxUQ.toggled.connect(self.setEnabledUQ)
if self.objSimp.isUQActivate() and hasattr(self,'checkBoxUQ') :
self.checkBoxUQ.setChecked(True)
+ def setEnabledUQ(self) :
+ if self.checkBoxUQ.isChecked() : self.objSimp.ajouteAuxIncertains()
+ else : self.objSimp.enleveDesIncertains()
+
def setNom(self):
self.debutToolTip=""
nomTraduit=tr(self.objSimp.nom)
def setValeursApresBouton(self):
+ #print (self.objSimp.getValeur())
+ if self.node.item.definition.homo== 'constant' and self.objSimp.getValeur()==None :
+ self.CBChoix.addItem(tr("Choisir dans la partie probabiliste"))
+ self.CBChoix.setCurrentIndex(self.CBChoix.findText(tr("Choisir dans la partie probabiliste")))
+ self.CBChoix.setEnabled(0)
+ return
if self.objSimp.getValeur()==None :
self.CBChoix.setCurrentIndex(-1)
self.CBChoix.lineEdit().setText(tr("Select"))
if not(type(choix) == str) : choix=str(choix)
listeChoix.append(choix)
self.CBChoix.addItem(choix)
- self.CBChoix.setEditable(True)
- monCompleteur=QCompleter(listeChoix,self)
- monCompleteur.setCompletionMode(QCompleter.PopupCompletion)
- self.CBChoix.setCompleter(monCompleteur)
+ if self.node.item.definition.homo== 'constant' :
+ self.CBChoix.setEnabled(0)
+ if self.objSimp.getValeur() != None :
+ self.CBChoix.setStyleSheet(("\n"
+"QComboBox {\n"
+" border: 1px solid gray;\n"
+" background: rgb(0,255,0);\n"
+" color: rgb(24,24,7);\n"
+" }\n"
+"QComboBox::drop-down {\n"
+" image: none; \n"
+" }"))
+ else :
+ self.CBChoix.setEditable(True)
+ monCompleteur=QCompleter(listeChoix,self)
+ monCompleteur.setCompletionMode(QCompleter.PopupCompletion)
+ self.CBChoix.setCompleter(monCompleteur)
def choixSaisi(self):
self.CBChoix.lineEdit().setStyleSheet(("\n"
"""
"""
def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
- #print ("fact : ",node.item.nom)
+ #print ("fact : ",node.item.nom , node.item.object.nature)
Groupe.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
labeltext,fonte,couleur = self.node.item.getLabelText()
self.GroupBox.setText(tr(labeltext))
self.parentQt.commandesLayout.insertWidget(-1,self)
self.doitAfficherOptionnel=True
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)
+ if max < 2 and hasattr(self, 'RBPlus') : self.RBPlus.close()
+ if max > 2 and obj.alt_parent.nature == 'MCList' and len(obj.alt_parent) >= max and hasattr(self, 'RBPlus') : self.RBPlus.close()
+
+ if max > 2 and definition.statut == 'cache' and hasattr(self, 'RBPlus') : self.RBPlus.close()
def enterEvent(self,event):
#print "enterEvent ", self.node.item.getLabelText()[0]
def setValeurs(self):
- #print ("dans setValeurs")
+ self.oldValeurTexte=''
self.politique=PolitiqueUnique(self.node,self.editor)
valeur=self.node.item.getValeur()
valeurTexte=self.politique.getValeurTexte(valeur)
chaine=""
-
if valeurTexte != None :
from decimal import Decimal
if isinstance(valeurTexte,Decimal):
elif repr(valeurTexte.__class__).find("PARAMETRE") > 0:
chaine = repr(valeur)
else :
- #PN ????
- #try :
- # chaine=QString("").setNum(valeurTexte)
- #except :
chaine=str(valeurTexte)
self.oldValeurTexte=chaine
self.lineEditVal.setText(chaine)
if str(self.lineEditVal.text())=="" or str(self.lineEditVal.text())==None : return
except : pass
SaisieValeur.LEvaleurPressed(self)
- self.parentQt.donneFocus()
+ #self.parentQt.donneFocus()
self.setValeurs()
self.reaffiche()
#print ('attention try devient if 1')
self.ouvreFichiers()
except EficasException as exc:
- #except:
- print ("je suis dans le except")
+ print ("je suis dans le except", exc)
if self.salome == 0 : exit()
#self.adjustSize()
self.demande=False
self.fileNew()
+ def ajoutUQ(self):
+ self.menuUQ = self.menubar.addMenu(tr("Incertitude"))
+ self.actionUQ = QAction(self)
+ self.actionUQ.setText(tr("Sauve Incertitude"))
+ self.menuUQ.addAction(self.actionUQ)
+ self.actionUQ.triggered.connect(self.handleSortieUQ)
+
def ajoutN1(self):
return
self.menuN1 = self.menubar.addMenu(tr("Process Output"))
self.connectRechercherDsCatalogue()
self.ajoutSortieComplete()
+
def lookSuiteTelemac(self):
self.enleverActionsStructures()
self.enlevernewInclude()
def handleDeplier(self):
self.viewmanager.handleDeplier()
+ def handleSortieUQ(self):
+ self.viewmanager.handleSortieUQ()
+
def ajoutCommentaire(self):
self.viewmanager.ajoutCommentaire()
self.appliEficas.titre=self.titre
self.QWParent.titre=self.titre
+ # incertitude ?
+ if hasattr(self.cata, 'avecIncertitude') and self.appliEficas.ssIhm == False:
+ self.appliEficas.ajoutUQ()
def importCata(self,cata):
"""
if maPage : self.myQtab.setTabText(self.myQtab.indexOf(maPage),os.path.basename(fichier))
return result
+
def closeTab(self,indexAFermer):
self.handleClose(indexAFermer = indexAFermer)
self.myQtab.setTabText(index,fileName)
return ok
+ def handleSortieUQ(self):
+ index=self.myQtab.currentIndex()
+ if index < 0 : return
+ editor=self.dictEditors[index]
+ ok, newName = editor.saveUQFile()
+ return ok
+
def saveCompleteCurrentEditor(self):
index=self.myQtab.currentIndex()
if index < 0 : return
# -----------------------------------
return self.viewManagerSsIhm.fileLegerSaveAs(self,fileName)
+ def handleSortieUQ(self,fileName):
+# -----------------------------------
+ return self.viewManagerSsIhm.handleSortieUQ(self,fileName)
#--------------------------------
for k, v in list(self.definition.entites.items()):
if v.label != 'SIMP':
continue
- if k in args or v.statut == 'o':
+ if k in args or v.statut in ('o', 'd'):
#
# Creation par appel de la methode __call__ de la definition de la sous entite k de self
# si une valeur existe dans args ou est obligatoire (generique si toutes les
"""
nature = 'MCSIMP'
- def __init__(self, val, definition, nom, parent,objPyxbDeConstruction):
+ def __init__(self, val, definition, nom, parent, objPyxbDeConstruction):
"""
Attributs :
self.etape = self.parent.etape
else:
# Le mot cle simple a été créé sans parent
- # est-ce possible ?
- print ('je suis dans le else sans parent du build')
+ # appel particulier dans getChild
+ #print ('je suis dans le else sans parent du build')
self.jdc = None
self.cata = None
self.niveau = None
Un mot-clé simple est caractérisé par les attributs suivants :
- type : cet attribut est obligatoire et indique le type de valeur attendue
- fr : chaîne documentaire en français
- - statut : obligatoire ou facultatif ou caché
+ - statut : obligatoire ou facultatif ou caché ou cache avec defaut (d)
- into : valeurs autorisées
- intoSug : valeurs possibles mais des valeurs autres du bon type peuvent etre entrees par l utilsateur
- defaut : valeur par défaut
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient le plugin generateur de fichier au format
+ UQ pour EFICAS.
+
+"""
+from __future__ import print_function
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import traceback
+import types,re,os
+import Accas
+
+from .generator_python import PythonGenerator
+from .textePersalys import headerScriptPersalys, fonctionScriptPersalys
+from .textePersalys import leMainPersalys, inputHeaderPersalys, outputHeaderPersalys
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : 'UQ',
+ # La factory pour creer une instance du plugin
+ 'factory' : UQGenerator,
+ }
+
+
+class UQGenerator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas 'normal'
+ un texte au format eficas avec balise
+ un script python permettant de piloter Persalys
+
+ """
+
+ def gener(self,jdc,format='beautifie'):
+ print (jdc.code)
+ if jdc.nature != 'JDC' :
+ self.commentaire= 'il faut un JDC Valide'
+ return 0
+ self.jdc=jdc
+ ret, commentaire = self.analyseIncertitude()
+ if not ret :
+ self.commentaire=commentaire
+ return ret
+ self.inGenerUQ=True
+ self.textUQ=PythonGenerator.gener(self,jdc,format)
+ self.inGenerUQ=False
+ self.text=PythonGenerator.gener(self,jdc,format)
+ return self.text
+
+ def writeUQ(self,fichier):
+ # il manque le checksum
+ fichierUQComm=fichier.split('.')[-2]+'_UQ.comm'
+ if not self.writeFile(fichierUQComm) : return (0, 'impossible de sauvegarder le .comm')
+ fichierUQ=fichier.split('.')[-2]+'_UQBalise.comm'
+ try :
+ with open(fichierUQ, "w") as fp:
+ fp.write(self.textUQ)
+ except : return (0,'impossible de sauvegarder le _UQ.py')
+ fichierUQExe=fichier.split('.')[-2]+'_UQ.py'
+ #try :
+ if 1 :
+ with open(fichierUQExe, "w") as fp:
+ fp.write(self.txtScriptPersalys)
+ #except : return (0,'impossible de sauvegarder le _UQ.py')
+ return (1, None)
+
+ def generPROC_ETAPE(self,obj):
+ if not self.inGenerUQ : return PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom == 'ExpressionIncertitude' and self.inGenerUQ : return ''
+ else : return PythonGenerator.generPROC_ETAPE(self,obj)
+ # il faut remplacer @xxx@
+ # DU coup qu est ce que xxx
+
+ def generMCSIMP(self,obj) :
+ if not self.inGenerUQ : return PythonGenerator.generMCSIMP(self,obj)
+ if not obj in self.mcIncertains : return PythonGenerator.generMCSIMP(self,obj)
+ else : return '@'+obj.nom+'@'
+
+ def analyseIncertitude(self) :
+ self.txtScriptPersalys = ''
+ etapeIncertitude=self.jdc.getEtapesByName('ExpressionIncertitude')
+ if etapeIncertitude == [] : return(0, 'il faut au moins un mot-clef ExpressionIncertitude')
+ if len(etapeIncertitude) !=1 : return(0, 'il faut au plus un mot-clef ExpressionIncertitude')
+ etapeIncertitude = etapeIncertitude[0]
+ incertitudeInput = etapeIncertitude.getChildOrChildInBloc('Input')
+ self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc('VariableProbabiliste')
+ self.mcIncertains = []
+ self.nomsDesVariablesInput = []
+ self.chaineDesVariablesInput=''
+ for mc in self.lesVariablesInput :
+ self.nomsDesVariablesInput.append(mc.variableDeterministe.nom)
+ self.chaineDesVariablesInput+=mc.variableDeterministe.nom + ', '
+ self.mcIncertains.append(mc.variableDeterministe)
+ sectionOutput = etapeIncertitude.getChildOrChildInBloc('Output')[0]
+ self.chaineDesVariablesInput=self.chaineDesVariablesInput[0:-2]
+
+ self.lesVariablesOutput = sectionOutput.getChildOrChildInBloc('VariableDeSortie')
+ self.variablesOutput = {}
+ self.chaineDesVariablesOutput=''
+ listeDesVariablesOutput=[] # pour ordre en 3.5
+ for mc in self.lesVariablesOutput :
+ nomVar = mc.getChildOrChildInBloc('NomDeLaVariable').valeur
+ listeDesVariablesOutput.append(nomVar)
+ self.chaineDesVariablesOutput+=nomVar+ ', '
+ Fonctions = mc.getChildOrChildInBloc('FonctionDAggregation').valeur
+ self.variablesOutput [nomVar]=Fonctions
+ print (self.variablesOutput)
+ self.chaineDesVariablesOutput=self.chaineDesVariablesOutput[0:-2]
+
+ self.creeScriptPersalys()
+ return (1, '')
+ # listeDesVariables, nomDesVariables, dicoDesVariables)
+
+ def creeTexteInputVariables(self,indent):
+ texte=''
+ for v in self.lesVariablesInput :
+ loiDistribution= v.getChildOrChildInBloc('Distribution').valeur
+ if loiDistribution in UQGenerator.__dict__:
+ Appli.__dict__[self.code.upper()](self,)
+
+ texte += (v.nom)+'\n'
+ return texte
+
+ def creeScriptPersalys(self, debug=True) :
+ wrapperDir = os.path.abspath(os.path.dirname(__file__))
+ wrapperName = "eficas_wrapper"
+ nomEtude = "monEtude"
+ if debug : print ('nomEtude : ', nomEtude, 'wrapperDir :', wrapperDir, 'wrapperName : ', wrapperName)
+
+ self.txtScriptPersalys += headerScriptPersalys.format (wrapperDir, wrapperName )
+ self.txtScriptPersalys += fonctionScriptPersalys.format ( self.chaineDesVariablesInput, self.chaineDesVariablesOutput )
+ self.txtScriptPersalys += leMainPersalys.format (nomEtude,nomEtude,nomEtude,)
+ indent = ' '
+ self.txtScriptPersalys += inputHeaderPersalys.format(indent,indent)
+ self.txtScriptPersalys +=self.creeTexteInputVariables(indent)
+ self.txtScriptPersalys += outputHeaderPersalys.format(indent,indent)
+
+
+
--- /dev/null
+# ----------------------------------
+# headerScriptPersalys
+# Parametres pour format :
+# nom de l etude, nom de l etude, nom de l etude, path pour wrapper, wrapper, nom de la fonction
+#sys.path[:0]=[{}]
+
+headerScriptPersalys = """#! /usr/bin/env python
+# ----------------------------------------------
+# Script genere pour lancement Etude Probabiliste
+# ----------------------------------------------
+
+# Chargement du module systeme
+import sys,os
+# Chargement du module OpenTURNS
+import openturns
+import persalys
+# Chargement de Eficas Wrapper
+from {} import {}
+
+"""
+# ----------------------------------
+# fonctionScriptPersalys
+fonctionScriptPersalys = """def _exec({}):
+# ---------------------
+
+# A completer
+
+ return {}
+"""
+
+inputHeaderPersalys = """
+{}# definition des Inputs
+{}# ---------------------
+"""
+inputPersalysUniform='{}{} = persalys.Input({}, {})'
+inputPersalys='{}{} = persalys.Input({}, {})'
+
+outputHeaderPersalys = """
+{}# definition des Outputs
+{}# ----------------------
+"""
+
+
+leMainPersalys="""
+# ------------------
+# definition du main
+# ------------------
+if __name__ == '__main__':
+ {} = persalys.Study('{}')
+ persalys.Study.Add({})
+"""
+# a = persalys.Input('a', 0, '')
+# b = persalys.Input('b', 0, '')
+# d = persalys.Output('d', '')
+# inputs = [a, b]
+# outputs = [d]
+
+
+if __name__ == "__main__":
+ pass
--- /dev/null
+def wrapperComm () :
+ pass
