From 76ef5186bf87734146ff8218cc9037c34be01e77 Mon Sep 17 00:00:00 2001 From: PASCALE NOYRET Date: Tue, 21 Jun 2022 18:24:00 +0200 Subject: [PATCH] Chgt de la reference sur l objet deterministe --- Ihm/I_ETAPE.py | 3 +++ Ihm/I_JDC.py | 17 +++++++++++++++++ Ihm/I_MCBLOC.py | 3 +++ Ihm/I_MCFACT.py | 14 ++++++++++++++ Ihm/I_MCLIST.py | 4 ++++ Ihm/I_MCSIMP.py | 7 ++++++- Ihm/I_OBJECT.py | 25 +++++++++++++++++++++++++ Ihm/I_PROC_ETAPE.py | 6 ++++++ Noyau/N_SIMP.py | 9 +++++++++ ReacteurNumerique/cata_UQ.py | 5 +++-- convert/convert_UQPython.py | 15 +++++++++++---- generator/generator_UQ.py | 15 +++++++++++++-- 12 files changed, 114 insertions(+), 9 deletions(-) diff --git a/Ihm/I_ETAPE.py b/Ihm/I_ETAPE.py index 31172dd2..4a3aad74 100644 --- a/Ihm/I_ETAPE.py +++ b/Ihm/I_ETAPE.py @@ -374,6 +374,9 @@ class ETAPE(I_MCCOMPO.MCCOMPO): def getGenealogiePrecise(self): return [self.nom] + def getMCPath(self): + return [self.nom, '@sdname '+self.sd.nom+ ' @'] + def getNomDsXML(self): # en xml on a un choice index=0 diff --git a/Ihm/I_JDC.py b/Ihm/I_JDC.py index 9488009f..f87e3033 100644 --- a/Ihm/I_JDC.py +++ b/Ihm/I_JDC.py @@ -690,9 +690,26 @@ class JDC(I_OBJECT.OBJECT): if l : l_mc.extend(l) return l_mc + def getMCPath(self): + return [] + def getGenealogiePrecise(self): return [] + def getObjetByMCPath(self,MCPath): + etape=None + nomEtape = MCPath[0] + nomSuivant = MCPath[1] + if nomSuivant.startswith('@sdname '): + nomEtape=nomSuivant.split(' ')[1] + etape=self.getEtapeByConceptName(nomEtape) + elif nomSuivant.startswith('@index '): + indexEtape=nomSuivant.split(' ')[1] + etape=self.getEtapesByName(nomEtape)[indexEtape] + if not etape : return None + return etape.getObjetByMCPath(MCPath[2:]) + + def getGenealogie(self): """ Retourne la liste des noms des ascendants de l'objet self diff --git a/Ihm/I_MCBLOC.py b/Ihm/I_MCBLOC.py index c96a9f80..e0e61282 100644 --- a/Ihm/I_MCBLOC.py +++ b/Ihm/I_MCBLOC.py @@ -23,3 +23,6 @@ class MCBLOC(I_MCCOMPO.MCCOMPO): def getNomDsXML(self): return self.parent.getNomDsXML() + + def getMCPath(self): + return self.parent.getMCPath() diff --git a/Ihm/I_MCFACT.py b/Ihm/I_MCFACT.py index b42c028c..81378d82 100644 --- a/Ihm/I_MCFACT.py +++ b/Ihm/I_MCFACT.py @@ -92,6 +92,20 @@ class MCFACT(I_MCCOMPO.MCCOMPO): else: return [nom.strip()] + def getMCPath(self): + objet = self.parent.getChild(self.nom, restreint='oui') + if objet is None or objet is self: return ('mauvais MCPath') + if len(objet) > 1: index = objet.getIndex(self) + else : index = 0 + nom = self.nom + if self.parent: + l=self.parent.getMCPath() + else: + l=[] + l.append(nom.strip()) + l.append('@index ' +str(index)+ ' @') + return l + def initModif(self): """ diff --git a/Ihm/I_MCLIST.py b/Ihm/I_MCLIST.py index ea3b4ba6..e5f69424 100644 --- a/Ihm/I_MCLIST.py +++ b/Ihm/I_MCLIST.py @@ -235,6 +235,10 @@ class MCList: else: return [] + def getMCPath(self): + if self.parent: return self.parent.getMCPath() + else: return [] + def getGenealogie(self): """ Retourne la liste des noms des ascendants. diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 05db2c6c..c224e544 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -914,6 +914,11 @@ class MCSIMP(I_OBJECT.OBJECT): newVariable.variableDeterministe = self self.variableProbabiliste=newVariable + + if self.etape.nature== 'OPERATEUR' : + itemObjet=newVariable.addEntite('ObjectName', 0) + itemObjet.definition.addInto(self.etape.sd.nom) + itemObjet.setValeur(self.etape.sd.nom) itemModelVariable=newVariable.getChild('ModelVariable') itemModelVariable.setValeur(self.nom) @@ -921,7 +926,7 @@ class MCSIMP(I_OBJECT.OBJECT): itemConsigne.setValeur('la valeur entrée pour {} est {}'.format(self.nom, self.valeur)) itemXPath=newVariable.getChild('MCPath') - itemXPath.setValeur(self.getGenealogiePrecise()) + itemXPath.setValeur(self.getMCPath()) #print (itemXPath) self.definition.siValide = self.changeValeursRefUQ diff --git a/Ihm/I_OBJECT.py b/Ihm/I_OBJECT.py index b4d58b84..4dc804a9 100644 --- a/Ihm/I_OBJECT.py +++ b/Ihm/I_OBJECT.py @@ -117,6 +117,31 @@ class OBJECT: else: return [self.nom.strip()] + def getMCPath(self): + if self.parent: + l=self.parent.getMCPath() + l.append(self.nom.strip()) + return l + else: + # a priori on ne devrait pas passer la + print ('Erreur dans getMCPath de I_OBJECT') + return [self.nom.strip()] + + def getObjetByMCPath(self,MCPath): + # a revoir avec les MCFACTs dans les MCLists + debug = 1 + if debug : print ('getObjetByMCPath pour', self, self.nom) + objet=None + nomFils=MCPath[0] + if debug : print ('nomFils', nomFils) + if debug : print ('MCPath restant',MCPath[1:]) + if MCPath[1:] == [] or MCPath[1:] == () : + if debug : print ('objFils',self.getChildOrChildInBloc(nomFils)) + return self.getChildOrChildInBloc(nomFils) + else : + objetFils=self.getChildOrChildInBloc(nomFils) + if debug : print ('objFils dans le else',objetFils) + return objetFils.getObjetByMCPath(MCPath[1:]) def getGenealogie(self): """ diff --git a/Ihm/I_PROC_ETAPE.py b/Ihm/I_PROC_ETAPE.py index d775f59c..e4354b0f 100644 --- a/Ihm/I_PROC_ETAPE.py +++ b/Ihm/I_PROC_ETAPE.py @@ -73,6 +73,12 @@ class PROC_ETAPE(I_ETAPE.ETAPE): for child in self.mcListe : child.replaceConcept(old_sd,sd) + + def getMCPath(self): + index=self.jdc.getIndex(self) + return [self.nom, '@index '+str(index)+ ' @'] + + def delieIncertitude(self): mcVP=self.getChild('Input').getChild('VariableProbabiliste') for vp in mcVP : diff --git a/Noyau/N_SIMP.py b/Noyau/N_SIMP.py index fdeae65b..b61b0a11 100644 --- a/Noyau/N_SIMP.py +++ b/Noyau/N_SIMP.py @@ -152,6 +152,15 @@ class SIMP(N_ENTITE.ENTITE): self.filtreVariables = [] self.metAJour=metAJour + def changeInto(self, listeDesIntos): + self.into=listeDesIntos + + def addInto(self, nvlInto): + self.into.append(nvlInto) + + def changeStatut(self, nvlStatut): + self.statut=nvlStatut + def verifCata(self): """ Cette methode sert à valider les attributs de l'objet de définition diff --git a/ReacteurNumerique/cata_UQ.py b/ReacteurNumerique/cata_UQ.py index 89a78a80..a8b28b61 100644 --- a/ReacteurNumerique/cata_UQ.py +++ b/ReacteurNumerique/cata_UQ.py @@ -1638,7 +1638,7 @@ def creeOutput(monDicoVarSortie): def creeOperExpressionIncertitude(monDicoVarDeter, monDicoVarSortie): listeDesVariablesPossibles = list(monDicoVarDeter.keys()) monOutput = creeOutput(monDicoVarSortie) - objectName = SIMP ( statut = "o", typ = 'TXM', homo='constant'), + objectName = SIMP ( statut = "f", typ = 'TXM', into=[], fenetreIhm='menuDeroulant', homo='constant' ) # on ne met pas [] pour la projection XSD, intoXML=? modelVariable = SIMP ( statut = "o", typ = ( 'TXM'), fr = "Variable d'entrée du modèle", @@ -1653,11 +1653,12 @@ def creeOperExpressionIncertitude(monDicoVarDeter, monDicoVarSortie): # Attention # l ordre des motclefs en 3.7 a l air de dépendre de l ordre de creation des objets # et non d un dict ordonné. on retombe toujours sur ce pb - return PROC ( nom = "ExpressionIncertitude", #UIinfo={"groupes":("CACHE",)}, + return PROC ( nom = "ExpressionIncertitude", UIinfo={"groupes":("CACHE",)}, Input = FACT( max=1, statut ='o', VariableProbabiliste = FACT ( max='**', statut ='cache', fr = "Variable probabiliste", ang = "Probabilistic variable", + ObjectName = objectName, ModelVariable = modelVariable, Consigne = laConsigne, MCPath = MCPath, diff --git a/convert/convert_UQPython.py b/convert/convert_UQPython.py index 5eb17eeb..073308c8 100644 --- a/convert/convert_UQPython.py +++ b/convert/convert_UQPython.py @@ -62,11 +62,18 @@ class pythonUQParser(Pythonparser): if not (mcVDPath) : mc.parent.suppentite(mc) break # on admet ici que le . comm n est pas valide + mcModelVariable=mc.getChild('ModelVariable') + mcModelVariable.definition.addInto(mcModelVariable.valeur) + #try : + # mcObjectName=mc.getChild('ObjectName') + # mcObjectName.changeStatut('f') + #except : + # pass mcCherche=jdc.getObjetByMCPath(mcVDPath) - for mcFils in mcVDPath[1:]: - if debug : print(mcCherche, mcFils) - mcCherche=mcCherche.getChildOrChildInBloc(mcFils) - if debug : print(mcCherche, mcFils) + if not (mcCherche) : + mc.parent.suppentite(mc) + break # on admet ici que le . comm n est pas valide + if debug : print(mcCherche) if mc.nature=='MCFACT' : mc[0].variableDeterministe=mcCherche mcCherche.variableProbabiliste=mc[0] diff --git a/generator/generator_UQ.py b/generator/generator_UQ.py index c36d1a50..99792240 100644 --- a/generator/generator_UQ.py +++ b/generator/generator_UQ.py @@ -65,6 +65,7 @@ class UQGenerator(PythonGenerator): def gener(self,jdc,format='beautifie'): self.indent = ' ' + self.nomsDesVariablesInput2 = [] print (jdc.code) if jdc.nature != 'JDC' : @@ -117,7 +118,13 @@ class UQGenerator(PythonGenerator): 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+'@' + else : + # a refaire si on decide que les incertains sont sous des fact multiples + # ce qui ne me parait pas possible mais ? + if obj.etape.nature == 'OPERATEUR' : + return '@'+obj.etape.sd.nom +'__' + obj.nom+'@' + else : + return '@'+obj.nom+'@' def analyseIncertitude(self) : @@ -133,11 +140,15 @@ class UQGenerator(PythonGenerator): self.chaineDesVariablesInput='' for mc in self.lesVariablesInput : self.nomsDesVariablesInput.append(mc.variableDeterministe.nom) - self.chaineDesVariablesInput+=mc.variableDeterministe.nom + ', ' + if mc.variableDeterministe.etape.nature == 'OPERATEUR' : + self.chaineDesVariablesInput+=mc.variableDeterministe.etape.sd.nom +'__' + mc.variableDeterministe.nom + else : + self.chaineDesVariablesInput+=mc.variableDeterministe.nom + ', ' self.mcIncertains.append(mc.variableDeterministe) sectionOutput = etapeIncertitude.getChildOrChildInBloc('Output')[0] self.chaineDesVariablesInput=self.chaineDesVariablesInput[0:-2] + return 1, "rrr" sectionPropagation = etapeIncertitude.getChildOrChildInBloc('Propagation')[0] self.Methode = sectionPropagation.getChildOrChildInBloc('Methode').valeur self.Result = sectionPropagation.getChildOrChildInBloc('Result')[0] -- 2.39.2