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
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
def getNomDsXML(self):
return self.parent.getNomDsXML()
+
+ def getMCPath(self):
+ return self.parent.getMCPath()
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):
"""
else:
return []
+ def getMCPath(self):
+ if self.parent: return self.parent.getMCPath()
+ else: return []
+
def getGenealogie(self):
"""
Retourne la liste des noms des ascendants.
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)
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
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):
"""
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 :
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
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",
# 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,
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]
def gener(self,jdc,format='beautifie'):
self.indent = ' '
+ self.nomsDesVariablesInput2 = []
print (jdc.code)
if jdc.nature != 'JDC' :
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) :
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]
