cata.dictTypesXSD[nom].append(self)
def definitNomDuTypePyxb(self,forceACreer=False,debug=False):
+ #if self.nom == 'A' : debug = True
if debug : print ('definitNomDuTypePyxb', self, self.nom,self.nomComplet(),forceACreer)
#PNPN
if hasattr(self,'nomDuTypePyxb') : self.aCreer = False; return self.nomDuTypePyxb
- #debug=False
if debug : print ('definitNomDuTypePyxb traitement pour ', self.nom)
self.aCreer = True
cata = CONTEXT.getCurrentCata()
nom='T_'+self.nom
if (hasattr (self, 'nomXML')) and self.nomXML != None : nom='T_'+self.nomXML
+ if debug : print (nom in cata.dictTypesXSD.keys())
if not (nom in cata.dictTypesXSD.keys()) :
if debug : print ('definitNomDuTypePyxb encore jamais traite ', self.nom , ' a pour type' , nom)
cata.dictTypesXSD[nom] = [self,]
self.nomDuTypePyxb=nom
return nom
+ if debug : print ( cata.dictTypesXSD[nom])
+ if debug : print ('definitNomDuTypePyxb deja traite ', self.nom , ' suite de l algo' )
if nom == 'T_Consigne' : return nom
if debug : print ('forceACreer : ', forceACreer)
+ debug=True
if not forceACreer :
self.aCreer = False
listePossible=cata.dictTypesXSD[nom]
- if debug : print ('listePossible : ', listePossible)
+ if debug : print ('listePossible : ', listePossible, 'pour ', nom )
indice=0
while (indice < len(listePossible)) :
objAComparer=listePossible[indice]
# ----------------------------------------
def __init__(self,nom,listeDeCreation,pere, debug=False):
-
+ debug=True
+ #if pere.nom == 'Test_Ambigu' : debug=True
if debug :
- for i in listeDeCreation : print (i.nom)
+ print ('___________________________________________________________________')
+ for i in listeDeCreation :
+ print (i.nom)
+ print (i, type(i))
+ print (i.possedeDejaUnMCFactorise)
+ print ('___________________________________________________________________')
self.label='BlocAmbigu'
self.nom=nom
self.pere=pere
self.typesXSDDejaDumpes=[]
self.ordre_mc=[]
self.lesConditions = 'Possible Conditions : '
+ if debug : print ('je suis dans compoFactoriseAmbigu pour', self.pere, self.pere.nom)
+ doitReecrireLesTypes=False
for mc in listeDeCreation :
if hasattr(mc, 'condition'):self.lesConditions += '\n\t\t\t\t\t\t' + mc.condition
+ doitReecrireLesTypes+=mc.possedeDejaUnMCFactorise
self.mcXSD.append(mc)
self.ordre_mc.append(mc.nom)
-
+ if debug : print ('doitReecrireLesTypes', doitReecrireLesTypes)
if debug : print (self.mcXSD)
if debug : print (self.ordre_mc)
self.construitEntites(self.mcXSD)
self.constructionArbrePossibles()
+ debug=False
+
lesPossibles=deepcopy(self.arbrePossibles)
if debug : print ('lesPossibles ', lesPossibles)
lesPossibles.remove([])
if debug : print ('________________ init de compoAmbigu',self.nom, lesPossibles)
if debug : print ('self.entites', self.entites)
+ cata = CONTEXT.getCurrentCata()
+ if doitReecrireLesTypes :
+ for nom in self.entites.keys() :
+ for mc in self.entites[nom]:
+ try : cata.dictTypesXSD[nom].remove(mc)
+ except : pass
+ cata.dictTypesXSD[nom].remove(mc)
+ if hasattr(mc, 'nomDuTypePyxb'): delattr(mc, 'nomDuTypePyxb'); print ('iiii', nom)
self.mcXSD=self.factoriseEtCreeDump(lesPossibles,nomAppel='Root')
if debug : print ('self.mcXSD',self.mcXSD)
self.texteComplexe += finTypeSubstDsBlocFactorise
return False
def construitEntites(self, laListe):
+ debug = True
for mc in laListe :
if mc.nom in self.entites.keys() : self.entites[mc.nom].append(mc)
else : self.entites[mc.nom] = [mc,]
+ if debug : print ('mc.nom', mc.nom, hasattr(mc, 'nomDuTypePyxb'))
if mc.label == 'BLOC' or mc.label == 'BlocAmbigu':
self.ajouteLesMCFilsAEntite(mc)
def ajouteAuxTextes(self,nomMC,indent,debug=False) :
if debug :
print ('______________________________________________________')
- print ('ajouteAuxTextes', nomMC, self.nom)
+ print ('ajouteAuxTextes', nomMC, self.nom, self.entites[nomMC])
# for i in self.entites.keys() : print (self.entites[i][0].nom)
if (indent > 3) : indent = indent - 3
if debug : print (nomMC, 'dans ajoute vraiment aux textes' )
if len(self.entites[nomMC]) == 1:
mc=self.entites[nomMC][0]
- #print (mc.nom, mc.dumpXsd)
mc.dumpXsd(dansFactorisation=True)
self.texteComplexe += '\t'*(indent) + mc.texteElt
if mc.aCreer : self.texteComplexeVenantDesFils += mc.texteComplexe
# cette boucle ne fonctionne que pour des SIMP
+ #if nomMC=='A': debug=True
resteATraiter=copy(self.entites[nomMC])
if debug :
- print ('________ calcul des unions resteATraiter', resteATraiter)
- for i in resteATraiter : print (i.nom)
+ print ('________ calcul des unions resteATraiter', resteATraiter, self.nom)
+ #for i in resteATraiter : print (i.nom)
listePourUnion=[]
first=1
while resteATraiter != [] :
if not (mc.compare(autre)) : nvlListeATraiter.append(autre)
resteATraiter=copy(nvlListeATraiter)
+ #if nomMC=='A': debug=True
if debug : print ('listePourUnion : ', listePourUnion)
if len(listePourUnion) == 1:
mc=listePourUnion[0]
# pour accepter les PROC et ...
#
if debug : print ('dumpXsd', self.nom, self.aCreer)
+ debug=False
if self.aCreer or dansFactorisationDeFusion:
if not dansFactorisationDeFusion : self.texteComplexe = debutTypeCompo.format(self.nomDuTypePyxb)
if (isinstance(self,X_OPER) or isinstance(self,X_PROC)) and avecEltAbstrait :
self.chercheListesDeBlocsNonDisjoints()
for l in list(self.listeDesBlocsNonDisjoints) :
if not(self.besoinDeFactoriserTrivial(l)) : self.listeDesBlocsNonDisjoints.remove(l)
- else : self.factorise(l)
+ else :
+ self.possedeDejaUnMCFactorise = 1
+ self.factorise(l)
def chercheListesDeBlocsNonDisjoints(self):
self.listeDesBlocsNonDisjoints=[]
def dumpXsd(self, dansFactorisation=False, multiple=False, first=False, debug=False):
#debug = True
#if PourTraduction : print (self.nom)
+ #if self.nom == 'A' : debug = True
if debug : print ('X_SIMP dumpXsd pour', self.nom, '___________________________')
+ debug=False
self.prepareDumpXSD()
# si inUnion la comparaison est fausse : on cree le nomDuType
if multiple : self.inUnion=True
else :
self.nomDuTypePyxb='NonDetermine'
+ #if self.nom == 'A' : debug = True
if debug : print ('nomDuTypePyxb', self.nomDuTypePyxb)
- if debug : print ('aCreer', self.aCreer)
+ if debug : print ('---------------------------- aCreer', self.aCreer)
+ debug = False
# on se sert des listes ou non pour la gestion des minOccurs /maxOccurs est > 0
if not multiple : self.texteSimple += debutSimpleType.format(self.nomDuTypePyxb)
else : self.texteSimple += debutSimpleTypeSsNom
+ # gestion des elements constants
+ if self.homo == "constant" :
+ if type(self.defaut) in ( 'tuple', 'list'):
+ self.intoConstant = self.defaut
+ else :
+ self.intoConstant = [self.defaut,]
+ else :
+ self.intoConstant = None
# On est dans une liste
if self.max > 1 or self.max == '**' or self.max == float('inf') or hasattr(self.type[0], 'ntuple') :
self.texteSimple += debutTypeSimpleListe
self.texteSimple += "\t\t\t\t"+debutRestrictionBase.format(self.nomDuTypeDeBase)
if self.val_min != float('-inf') : self.texteSimple += "\t\t\t\t"+minInclusiveBorne.format(self.val_min)
if self.val_max != float('inf') and self.val_max != '**' : self.texteSimple +="\t\t\t\t"+ maxInclusiveBorne.format(self.val_max)
- if self.into != None:
+ if self.into != None or self.intoConstant != None:
# PN --> traduction des into
into=self.into
+ if self.intoConstant != None : into = self.intoConstant
if self.intoXML != None : into = self.intoXML
for val in into : self.texteSimple += "\t\t\t\t"+enumeration.format(val)
if PourTraduction :
self.texteSimple += debutRestrictionBase.format(self.nomDuTypeDeBase)
if self.val_min != float('-inf') : self.texteSimple += minInclusiveBorne.format(self.val_min)
if self.val_max != float('inf') and self.val_max != '**' : self.texteSimple += maxInclusiveBorne.format(self.val_max)
- if self.into != None:
+ if self.into != None or self.intoConstant != None:
into=self.into
+ if self.intoConstant != None : into = self.intoConstant
if self.intoXML != None : into = self.intoXML
for val in into : self.texteSimple += enumeration.format(val)
if PourTraduction :
def dumpSpecifiqueTuple(self,minOccurs):
+
self.nomDuTypeDeBase = self.traduitType()
tousPareil=True
# il faut gerer l aide et les defaut
# self.texteSimple += fermeSimpleType
# return
+ if self.min==0 : sequenceVide=True
+ else : sequenceVide=False
self.texteSimple = ''
complexeTypeTuple = tupleDebutComplexeType.format(self.nomDuTypePyxb)
num = 1
il faut encore rearranger cette liste (certains mots-cles deja
presents ne doivent plus etre proposes, regles ...)
"""
- return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico,), avecCache=avecCache)
+ return self.filtreListeMc(self.getListeMcOrdonneeBrute(liste,dico))
def getListeMcOrdonneeBrute(self,liste,dico):
"""
si avecCache=False on n inclut pas les MC dont le statut = cache
"""
liste = copy(liste_brute)
- #print (self.nom, liste_brute)
listeMcPresents = self.listeMcPresents()
# on enleve les mots-cles non permis par les regles
for regle in self.definition.regles:
def getObjetByMCPath(self,MCPath):
# a revoir avec les MCFACTs dans les MCLists
- debug = 1
+ debug = 0
if debug : print ('getObjetByMCPath pour', self, self.nom)
objet=None
nomFils=MCPath[0]
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.setText(tr("Le fichier .comm est invalide / incomplet \n Seuls les .comm et _UQ.comm seront sauvegardes"))
+ msgBox.addButton(tr("&Sauvegarder les .comm et _UQ.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)
+ ret, fichier = JDCEditorSsIhm.saveUQFile (self,fn)
if ret : self.fichier = fichier
if self.salome and ret:
self.appliEficas.addJdcInSalome( self.fichier)
#-----------------------------------#
def saveUQFile(self, fichier = None):
#------------------------------------#
- if fichier == None : print ("nom de fichier obligatoire pour sauvegarde"); return
+ if fichier == None :
+ self.informe ("nom de fichier obligatoire pour sauvegarde");
+ return 0, None
self.fichier=fichier
self.generator=generator.plugins['UQ']()
ret = self.generator.creeNomsFichiers(fichier)
+ if not ret :
+ self.informe('Sauvegarde UQ', self.generator.commentaire)
+ return ret, None
ret = self.generator.gener(self.jdc)
if not ret :
self.informe('Sauvegarde UQ', self.generator.commentaire)
- return (ret, self.generator.commentaire)
+ return ret, None
+ if ret == 2 :
+ self.informe('Sauvegarde UQ', self.generator.commentaire, critique=False)
+ return 1, fichier
ret = self.generator.writeUQ(fichier)
if not ret : self.informe('Sauvegarde UQ', self.generator.commentaire)
- print ('ok')
- return ret
+ else:
+ self.informe('Sauvegarde UQ', 'Sauvegardes des fichiers .comm, _UQ.comm effectuées.\n'\
+ 'Création des fichiers _UQ.py et _UQBalise.comm.',critique=False)
+ return ret, fichier
# ---------------------------------------------
# Methodes Surchargees par avecIhm
try :
#if 1 :
self.listeMc = self.obj.getListeMcOrdonnee(genea,self.jdc.cata_ordonne_dico)
- if self.node.item.nom == "cocagne_options" : print (self.listeMc)
listeNomsPresents=self.obj.dictMcPresents()
for regle in self.obj.getRegles():
(monToolTip,regleOk)=regle.verif(listeNomsPresents)
self.entites = args
self.affecter_parente()
self.txtNomComplet = ''
+ self.possedeDejaUnMCFactorise = False
def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None):
"""
class ENTITE(object):
"""
- Classe de base pour tous les objets de definition : mots cles et commandes
+ Classe de base pour tous les objets de definition : mots cles et commandes
Cette classe ne contient que des methodes utilitaires
Elle ne peut être instanciee et doit d abord être specialisee
"""
L'attribut entités doit contenir le dictionnaires des sous-entités
(clé = nom, valeur=objet)
+
+ Les attributs utiles pour la projection xsd sont aussi initialises
+ init non appele pour bloc
"""
self.regles = ()
self.entites = {}
self.txtNomComplet=''
self.redefinit=False
self.dejaPrepareDump=False
+ self.possedeDejaUnMCFactorise=False
def affecter_parente(self):
"""
fr="Options de modélisations spécifiques au code COCAGNE.",
ang="COCAGNE specific modeling options",
statut="o",
- n_threads=SIMP(
- fr="Nombre de threads alloués aux solveurs",
- ang="Number of threads allocated to the solvers",
- statut="f",
- typ="I",
- val_min=1),
core_elements_vs_dklib=SIMP(
fr=("Association des éléments du cœur aux bibliothèques neutroniques "
"sous la forme (assemblage combustible, DKLib)"),
statut="o",
typ="TXM",
into=("THYC", "CATHARE3", "FLICA4")),
- thyc_bloc=BLOC(
- condition="code == 'THYC'",
- thyc_options=FACT(
- fr="Options de modélisations spécifiques au code THYC.",
- ang="THYC specific modeling options",
- statut="o",
- n_threads=SIMP(
- fr="Nombre de threads alloués aux solveurs",
- ang="Number of threads allocated to the solvers",
- statut="f",
- typ="I",
- val_min=1))),
radial_meshing=FACT(
fr="Description du maillage radial thermohydraulique à l'échelle du composant",
ang="Thermalhydraulic radial meshing description at the component scale",
typ=Tuple(2), # TODO: Use a triplet (parameter, physic, format) instead of a doublet
validators=VerifPostTreatment(),
max="**"))
+
+#from cata_RN_UQ import *
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-"""Definition of the data model used by the integration bench.
-
-Warnings
---------
-EFICAS will import this file as Python module with the ``__import__`` special
-function so, this module must not use relative import.
-"""
-# pylint: disable=import-error
-# pylint: disable=too-few-public-methods
-
-# TODO: Create a main object that point on the different subobjects and force its name
-
-# EFICAS
-from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, VerifTypeTuple, Matrice
-from Accas import Tuple as _Tuple
-from Extensions.i18n import tr
-
-# Warning: The names of these variables are defined by EFICAS
-JdC = JDC_CATA(code="RN_EDG")
-VERSION_CATALOGUE = "V_0"
-
-# Define the minimum and the maximum number of elements (reflectors and fuel
-# assemblies) on the core's side
-NMIN_CORE_FUEL_ELTS = 1
-NMAX_CORE_FUEL_ELTS = 18
-
-# Available absorbing material type in the rod clusters
-ROD_COMPOSITIONS = (
- "Black", # Full AIC rods
- "Grey", # Mix between AIC and steel rods
- "B4C", # Full B4C rods
-)
-
-# Available options for the core elements rotation
-ASSEMBLY_ROTATIONS = (
- ".", # identity
- "R1", # 90° counter-clock
- "R2", # 180°
- "R3", # 270° counter-clock
- "UD", # up-down
- "LR", # left-right
- "TR", # transpose x/y
- "RT", # transpose x/-y
-)
-
-class Tuple(_Tuple):
- """Organize the data into a fixed size tuple.
-
- Warnings
- --------
- This class respect the EFICAS conventions.
- """
-
- def __convert__(self, valeur):
- if len(valeur) != self.ntuple:
- return None
- return valeur
-
-
-class VerifPostTreatment(VerifTypeTuple):
- """Validate the data comming from ``Scenario_data.post_processing``.
-
- Warnings
- --------
- This class respect the EFICAS conventions.
- """
- # pylint: disable=invalid-name
- # pylint: disable=missing-function-docstring
- # pylint: disable=no-self-use
-
- PHYSICS = ("Neutronics", "Thermalhydraulics")
- FORMATS = ("MED", "SUM", "MIN", "MAX", "MEAN")
-
- def __init__(self):
- super().__init__(("TXM", "TXM"))
- self.cata_info = ""
-
- def info(self):
- return tr(": vérifie les \ntypes dans un tuple")
-
- def infoErreurListe(self):
- return tr("Les types entres ne sont pas permis")
-
- def default(self, valeur):
- return valeur
-
- def isList(self):
- return 1
-
- def convertItem(self, valeur):
- if len(valeur) != len(self.typeDesTuples):
- raise ValueError(
- tr("%s devrait être de type %s ") % (valeur, self.typeDesTuples))
- ok = self.verifType(valeur)
- if ok == 0:
- raise ValueError(
- tr("%s devrait être de type %s (%d)") % (valeur, self.typeDesTuples, ok))
- if ok < 0:
- raise ValueError(
- tr("%s devrait être dans %s ") % (valeur[1], self.FORMATS))
- return valeur
-
- def verifItem(self, valeur):
- try:
- if len(valeur) != len(self.typeDesTuples):
- return 0
- ok = self.verifType(valeur)
- if ok != 1:
- return 0
- except: # pylint: disable=bare-except
- return 0
- return 1
-
- def verifType(self, valeur): # pylint: disable=arguments-differ
- ok = 0
- for v in valeur:
- if isinstance(v, (bytes, str)):
- ok += 1
- if ok == len(self.typeDesTuples):
- if valeur[1] in self.FORMATS:
- return 1
- return -1
- return 0
-
- def verif(self, valeur):
- if type(valeur) in (list, tuple):
- liste = list(valeur)
- for val in liste:
- if self.verifItem(val) != 1:
- return 0
- return 1
- return 0
-
-
-class _Assembly(ASSD):
- pass
-
-
-class _TechnoData(ASSD):
- pass
-
-
-class _RodBank(ASSD):
- pass
-
-
-class _ModelData(ASSD):
- pass
-
-
-class _ScenarioData(ASSD):
- pass
-
-
-Assembly = OPER(
- nom="Assembly",
- sd_prod=_Assembly,
- fr="Description d'un élément du cœur",
- ang="Core element description",
- assembly_type=SIMP(
- fr="Type d'élément cœur (assemblage combustible ou réflecteur",
- ang="Type of the core element (fuel assembly or reflector",
- statut="o",
- typ="TXM",
- into=("UOX", "MOX", "REF")),
- description=BLOC(
- condition="assembly_type != 'REF'",
- fr="Description d'un assemblage combustible",
- ang="Fuel assembly description",
- assembly_width=SIMP(
- fr="Pas inter-assemblage dans le cœur",
- ang="Fuel assembly pitch in the core",
- unite="m",
- statut="o",
- typ="R"),
- fuel_density=SIMP(
- fr=("Ratio entre masse volumique nominale et la masse volumique "
- "théorique des pastilles combustible"),
- ang=("Ratio between the nominal density and the theoretical "
- "density of the fuel pellets"),
- unite="g/cm3",
- statut="o",
- typ="R",
- defaut=0.95),
- radial_description=FACT(
- fr="Description radiale de l'assemblage combustible",
- ang="Fuel assembly radial description",
- statut="o",
- clad_outer_radius=SIMP(
- fr="Rayon externe de la gaine des crayons combustible",
- ang="Clad external radius of the fuel pins",
- unite="m",
- statut="o",
- typ="R"),
- guide_tube_outer_radius=SIMP(
- fr="Rayon externe des tubes guides",
- ang="Clad external radius of the guide tubes",
- unite="m",
- statut="o",
- typ="R"),
- fuel_rod_pitch=SIMP(
- fr="Pas inter-crayon dans l'assemblage",
- ang="Fuel pin pitch in the assembly",
- unite="m",
- statut="o",
- typ="R"),
- nfuel_rods=SIMP(
- fr="Nombre de crayons combustibles dans l'assemblage",
- ang="Number of fuel pins in the assembly",
- statut="o",
- typ="I")),
- axial_description=FACT(
- fr="Description axiale de l'assemblage combustible",
- ang="Fuel assembly axial description",
- statut="o",
- active_length_start=SIMP(
- fr="Altitude basse de la partie active",
- ang="Lower altitude of the active part",
- unite="m",
- statut="o",
- typ="R"),
- active_length_end=SIMP(
- fr="Altitude haute de la partie active",
- ang="Upper altitude of the active part",
- unite="m",
- statut="o",
- typ="R")),
- grids=FACT(
- fr="Description des grilles",
- ang="Grids description",
- statut="o",
- mixing=FACT(
- fr="Description des grilles de mélange",
- ang="Mixing grids description",
- statut="o",
- positions=SIMP(
- fr="Altitude basse de la grille",
- ang="Grid lower altitude",
- unite="m",
- statut="f",
- typ="R",
- max="**"),
- size=SIMP(
- fr="Hauteur de la grille",
- ang="Grid height",
- unite="m",
- statut="o",
- typ="R")),
- non_mixing=FACT(
- fr="Description des grilles de maintien",
- ang="Holding grids description",
- statut="o",
- positions=SIMP(
- fr="Altitude basse de la grille",
- ang="Grid lower altitude",
- unite="m",
- statut="f",
- typ="R",
- max="**"),
- size=SIMP(
- fr="Hauteur de la grille",
- ang="Grid height",
- unite="m",
- statut="o",
- typ="R")))))
-
-
-# TODO: Define the names of the possible compositions (Black, Grey, B4C, Hafnium and Pyrex)
-RodBank = OPER(
- nom="RodBank",
- sd_prod=_RodBank,
- fr="Description d'un groupe de grappes absorbantes",
- ang="Rod bank description",
- rod_type=SIMP(
- fr="Type de grappes absorbantes",
- ang="Type of rod clusters",
- statut="o",
- typ="TXM",
- into=("homogeneous", "heterogeneous")),
- description_HOM=BLOC(
- condition="rod_type == 'homogeneous'",
- fr="Description d'un groupe de grappes absorbantes homogènes axialement",
- ang="Axially homogeneous rod bank description",
- rod_composition=SIMP(
- fr=("Type de matériau absorbant des grappes absorbantes (Types "
- "autorisés : {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- ang=("Absorbing material type of the rod clusters (Authorized "
- "types: {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- statut="o",
- typ="TXM",
- into=ROD_COMPOSITIONS)),
- description_HET=BLOC(
- condition="rod_type == 'heterogeneous'",
- fr="Description d'un groupe de grappes absorbantes hétérogène axialement",
- ang="Axially heterogeneous rod bank description",
- bottom_composition=SIMP(
- fr=("Type de matériau absorbant dans la partie basse des grappes "
- "absorantes (Types autorisés : {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- ang=("Absorbing material type in the lower part of the rod "
- "clusters (Authorized types: {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- statut="o",
- typ="TXM",
- into=ROD_COMPOSITIONS),
- splitting_heigh=SIMP(
- fr=("Altitude de séparation entre la partie haute et la partie "
- "basse des grappes absorbantes"),
- ang=("Splitting height between the upper part and the lower part "
- "of the rod clusters"),
- unite="m",
- statut="o",
- typ="R"),
- upper_composition=SIMP(
- fr=("Type de matériau absorbant dans la partie haute des grappes "
- "absorantes (Types autorisés : {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- ang=("Absorbing material type in the upper part of the rod "
- "clusters (Authorized types: {})").format(
- ", ".join(ROD_COMPOSITIONS)),
- statut="o",
- typ="TXM",
- into=ROD_COMPOSITIONS)),
- step_height=SIMP(
- fr="Hauteur d'un pas",
- ang="Step height",
- unite="m",
- statut="o",
- typ="R"),
- nsteps=SIMP(
- fr="Nombre de pas du groupe de grappes",
- ang="Rod bank steps number",
- statut="o",
- typ="I"))
-
-
-def gen_assembly_maps():
- """Generate all the possible maps (one for each possible core size) for the
- data cointained in ``Techno_data.radial_description.assembly_map``."""
- # Build the default axes names
- xsym_list = list("ABCDEFGHJKLNPRSTUVWXYZ")
- xsym_list.reverse()
- ysym_list = ["%02d" % i for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS + 1)]
- ysym_list.reverse()
- def_xaxis = {}
- def_yaxis = {}
- for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS + 1):
- def_xaxis[i] = ["RW"] + xsym_list[-i:] + ["RE"]
- def_yaxis[i] = ["RS"] + ysym_list[-i:] + ["RN"]
-
- dico = {}
- for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS):
- dico["assembly_map_%d" % i] = BLOC(
- condition="nb_assembly == %d" % i,
- fr="Description radiale du cœur",
- ang="Core radial description",
- xaxis=SIMP(
- fr="Nom des repères radiaux du cœur suivant l'axe ouest-est",
- ang="Name of core radial marks following the west-east axis",
- statut="o",
- typ="TXM",
- min=i + 2,
- max=i + 2,
- defaut=def_xaxis[i]),
- yaxis=SIMP(
- fr="Nom des repères radiaux du cœur suivant l'axe nord-sud",
- ang="Name of core radial marks following the north-south axis",
- statut="o",
- typ="TXM",
- min=i + 2,
- max=i + 2,
- defaut=def_yaxis[i]),
- assembly_map=SIMP(
- fr=("Répartition radiale des assemblages combustibles et des "
- "réflecteurs dans le cœur"),
- ang=("Radial repartition of the fuel assemblies and the "
- "reflectors in the core"),
- statut="o",
- typ=Matrice(
- nbLigs=i + 2,
- nbCols=i + 2,
- typElt=_Assembly,
- listeHeaders=(
- ("RW","S","R","P","N","L","K","J","H","G","F","E","D","C","B","A","RE",),
- ("RS","15","14","13","12","11","10","09","08","07","06","05","04","03","02","01","RN",)), # pylint: disable=line-too-long
- defaut=(i + 2) * [(i + 2) * ["."]],
- coloree=True)),
- rotation_map=SIMP(
- fr="Rotation des éléments du cœur. Valeur possibles : {}".format(
- ", ".join([repr(elt) for elt in ASSEMBLY_ROTATIONS])),
- ang="Core elements rotation. Possible values : {}".format(
- ", ".join([repr(elt) for elt in ASSEMBLY_ROTATIONS])),
- statut="o",
- typ=Matrice(
- nbLigs=i + 2,
- nbCols=i + 2,
- typElt="TXM",
- typEltInto=ASSEMBLY_ROTATIONS,
- coloree=True),
- defaut=(i + 2) * [(i + 2) * ["."]]),
- rod_map=SIMP(
- fr="Répartition radiale des groupes de grappes dans le cœur",
- ang="Rod banks radial repartition in the core",
- statut="o",
- typ=Matrice(
- nbLigs=i + 2,
- nbCols=i + 2,
- valSup=1,
- valMin=-1,
- typElt="TXM",
- listeHeaders=None,
- coloree=True),
- defaut=(i + 2) * [(i + 2) * ["."]]),
- BU_map=SIMP(
- fr="Taux de combustion moyen des assemblages combustibles en GW.j/t",
- ang="Average burnup of the fuel assemblies in GW.d/t",
- statut="o",
- typ=Matrice(
- nbLigs=i + 2,
- nbCols=i + 2,
- valSup=90000.,
- valMin=0.,
- typElt="R",
- listeHeaders=None,
- coloree=True),
- defaut=(i + 2) * [(i + 2) * ["."]]))
- return dico
-
-
-Techno_data = OPER(
- nom="Techno_data",
- sd_prod=_TechnoData,
- fr="Description technologique du cœur",
- ang="Core technological description",
- assembly_list=SIMP(
- fr="Sélection des assemblages combustible",
- ang="Fuel assemblies selection",
- statut="o",
- typ=_Assembly,
- min=1,
- max="**"),
- rodbank_list=SIMP(
- fr="Sélection des groupes de grappes",
- ang="Rod banks selection",
- statut="o",
- typ=_RodBank,
- min=0,
- max="**"),
- radial_description=FACT(
- fr="Description radiale du cœur",
- ang="Radial description of the core",
- statut="o",
- nb_assembly=SIMP(
- fr="Nombre d'éléments combustible sur la tranche du cœur",
- ang="Number of fuel elements on one side of the core",
- statut="o",
- typ="I",
- into=list(range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS))),
- **(gen_assembly_maps())),
- axial_description=FACT(
- fr="Description axiale du cœur",
- ang="Axial description of the core",
- statut="o",
- lower_refl_size=SIMP(
- fr="Hauteur du réflecteur axial bas",
- ang="Height of bottom axial reflector",
- unite="m",
- statut="o",
- typ="R"),
- upper_refl_size=SIMP(
- fr="Hauteur du réflecteur axial haut",
- ang="Height of top axial reflector",
- unite="m",
- statut="o",
- typ="R")),
- nominal_power=SIMP(
- fr="Puissance thermique nominale du cœur",
- ang="Nominal thermal power of the core",
- unite="W",
- statut="o",
- typ="R"),
- Fuel_power_fraction=SIMP(
- fr="Fraction de la puissance dissipée dans le combustible",
- ang="Power fraction dissipated in the fuel",
- statut="o",
- typ="R",
- defaut=0.974),
- by_pass=SIMP(
- fr="Fraction du débit de bypass cœur",
- ang="Bypass core flow fraction",
- statut="o",
- typ="R",
- defaut=0.07),
- core_volumic_flowrate=SIMP(
- fr="Débit volumique cœur",
- ang="Core volume flowrate",
- unite="m3/h",
- statut="o",
- typ="R"))
-
-
-class _AssemblyDKLibFile(ASSD):
- """Manage informations about a fuel assembly DKLib file."""
-
-
-class _ReflectorDKLibFile(ASSD):
- """Manage informations about a reflector DKLib file."""
-
-
-AssemblyDKLibFile = OPER(
- nom="AssemblyDKLibFile",
- sd_prod=_AssemblyDKLibFile,
- fr="Description d'un fichier DKLib assemblage combustible",
- ang="Description of a fuel assembly DKLib file",
- filename=SIMP(
- fr="Nom du fichier DKLib",
- ang="DKLib filename",
- statut="o",
- typ=("Fichier", "DKLib Files (.dklib);;DKZip Files (.dkzip);;All Files ()", "Sauvegarde")),
- pattern=SIMP(
- fr="Nom du pattern à utiliser dans le fichier DKLib",
- ang="Name of the pattern to use in the DKLib file",
- statut="o",
- typ="TXM"),
- rod_bank_names=SIMP(
- fr=("Nom de la configuration de grappe dans la DKLib pour chaque type "
- "de matériaux absorbants disponibles dans le modèle sous la forme "
- "({{{}}}, nom dans la DKLib)").format(", ".join(ROD_COMPOSITIONS)),
- ang=("Name of the rod cluster configuration in the DKLib file for any "
- "type of absorbing materials available in the model under the form "
- "({{{}}}, name in the DKLib)").format(", ".join(ROD_COMPOSITIONS)),
- statut="o",
- typ=Tuple(2),
- # TODO: Check if the first string is ROD_COMPOSITIONS
- validators=VerifTypeTuple(("TXM", "TXM")),
- max="**"))
-
-
-ReflectorDKLibFile = OPER(
- nom="ReflectorDKLibFile",
- sd_prod=_ReflectorDKLibFile,
- fr="Description d'un fichier DKLib réflecteur",
- ang="Description of a reflector DKLib file",
- filename=SIMP(
- fr="Nom du fichier DKLib",
- ang="DKLib filename",
- statut="o",
- typ=("Fichier", "DKLib Files (.dklib);;DKZip Files (.dkzip);;All Files ()","Sauvegarde")),
- radial_pattern=SIMP(
- fr="Nom du pattern contenant les données du réflecteur radial",
- ang="Name of the pattern containing the radial reflector data",
- statut="o",
- typ="TXM"),
- lower_pattern=SIMP(
- fr="Nom du pattern contenant les données du réflecteur axial bas",
- ang="Name of the pattern containing the lower reflector data",
- statut="o",
- typ="TXM"),
- upper_pattern=SIMP(
- fr="Nom du pattern contenant les données du réflecteur axial haut",
- ang="Name of the pattern containing the upper reflector data",
- statut="o",
- typ="TXM"))
-
-
-# TODO: Split this class in two: neutronic and thermalhydraulic)
-# TODO: Or split this class in N classes (one for each code)
-Model_data = OPER(
- nom="Model_data",
- sd_prod=_ModelData,
- fr="Description de la modélisation physique",
- ang="Physical modeling description",
- physics=SIMP(
- fr="Sélection de la physique du modèle",
- ang="Physic model selection",
- statut="o",
- typ="TXM",
- into=("Neutronics", "Thermalhydraulics")),
- scale=SIMP(
- fr="Sélection de l'échelle du modèle",
- ang="Scale model selection",
- statut="o",
- typ="TXM",
- into=("system", "component", "local")),
- b_neutro_compo=BLOC(
- condition="physics == 'Neutronics' and scale == 'component'",
- fr="Description de la modélisation neutronique à l'échelle du composant",
- ang="Neutronic modeling description at the component scale",
- code=SIMP(
- fr="Sélection du code de neutronique cœur",
- ang="Core neutronic code selection",
- statut="o",
- typ="TXM",
- into=("COCAGNE", "APOLLO3")),
- cocagne_bloc=BLOC(
- condition="code == 'COCAGNE'",
- cocagne_options=FACT(
- fr="Options de modélisations spécifiques au code COCAGNE.",
- ang="COCAGNE specific modeling options",
- statut="o",
- core_elements_vs_dklib=SIMP(
- fr=("Association des éléments du cœur aux bibliothèques neutroniques "
- "sous la forme (assemblage combustible, DKLib)"),
- ang=("Association between the core elements and the neutronic libraries "
- "in the form (fuel assembly, DKLib)"),
- statut="f",
- typ=Tuple(2),
- # TODO: Check if the attribute assembly_type of the
- # Assembly object is 'REF' then the type of the
- # DKLibFile must be ReflectorDKLibFile and, if not,
- # the type of the DKLibFile must be AssemblyDKLibFile
- validators=VerifTypeTuple((_Assembly, (_AssemblyDKLibFile, _ReflectorDKLibFile))),
- max="**"))),
- # TODO: Implement the *4x4* mesh
- radial_meshing=FACT(
- fr="Maillage radial du cœur",
- ang="Core radial meshing",
- statut="o",
- flux_solver=SIMP(
- fr="Type de maillage radial du solveur de flux",
- ang="Radial mesh type for the flux solver",
- statut="o",
- typ="TXM",
- into=("subdivision", "pin-by-pin")),
- b_flux_subdivision=BLOC(
- condition="flux_solver == 'subdivision'",
- fr=("Paramètres pour les maillages radiaux de type subdivisé "
- "pour le solveur de flux"),
- ang=("Parameters for the subdivided radial meshes types for the "
- "flux solver"),
- flux_subdivision=SIMP(
- fr=("Nombre de sous-divisions à appliquer à chaque maille "
- "radiale pour le solveur de flux"),
- ang=("Subdivision number to apply to all radial meshes for "
- "the flux solver"),
- statut="o",
- typ="I")),
- feedback_solver=SIMP(
- fr="Type de maillage radial du solveur de contre-réaction",
- ang="Radial mesh type for the feedback solver",
- statut="o",
- typ="TXM",
- into=("subdivision", "pin-by-pin")),
- b_feedback_subdivision=BLOC(
- condition="feedback_solver == 'subdivision'",
- fr=("Paramètres pour les maillages radiaux de type subdivisé "
- "pour le solveur de contre-réaction"),
- ang=("Parameters for the subdivided radial meshes types for the "
- "feedback solver"),
- feedback_subdivision=SIMP(
- fr=("Nombre de sous-divisions à appliquer à chaque maille "
- "radiale pour le solveur de contre-réaction"),
- ang=("Subdivision number to apply to all radial meshes for "
- "the feedback solver"),
- statut="o",
- typ="I")))),
- b_thermo_compo=BLOC(
- condition="physics == 'Thermalhydraulics' and scale == 'component'",
- fr="Description de la modélisation thermohydraulique à l'échelle du composant",
- ang="Thermalhydraulic modeling description at the component scale",
- code=SIMP(
- fr="Sélection du code de thermohydraulique cœur",
- ang="Core thermalhydraulic code selection",
- statut="o",
- typ="TXM",
- into=("THYC", "CATHARE3", "FLICA4")),
- radial_meshing=FACT(
- fr="Description du maillage radial thermohydraulique à l'échelle du composant",
- ang="Thermalhydraulic radial meshing description at the component scale",
- statut="o",
- fluid=SIMP(
- fr="Méthode de maillage radial",
- ang="Radial meshing method",
- statut="o",
- typ="TXM",
- into=("subdivision", "subchannel")),
- b_fluid_subdivision=BLOC(
- condition="fluid == 'subdivision'",
- fr="Données spécifiques au maillage radial par subdivision",
- ang="Specific data for the radial meshing by subdivision",
- fluid_subdivision=SIMP(
- fr="Nombre de mailles radiales dans les assemblages combustibles",
- ang="Radial mesh number in the fuel assemblies",
- statut="o",
- typ="I")),
- pellet=SIMP(
- fr="Nombre de mailles radiales dans la pastille combustible",
- ang="Radial mesh number in the fuel pellet",
- statut="o",
- typ="I"),
- clad=SIMP(
- fr="Nombre de mailles radiales dans la gaine des crayons combustibles",
- ang="Radial mesh number in the clad of the fuel pins",
- statut="o",
- typ="I"))),
- b_scale_compo=BLOC(
- condition="scale == 'component'",
- fr="Description de la modélisation à l'échelle du composant",
- ang="Modeling description at the component scale",
- axial_meshing=FACT(
- fr="Maillage axial du cœur",
- ang="Core axial meshing",
- statut="o",
- lower_refl=SIMP(
- fr="Nombre de mailles axiales dans le réflecteur bas",
- ang="Axial mesh number in the lower reflector",
- statut="o",
- typ="I"),
- fuel=SIMP(
- fr="Nombre de mailles axiales dans la partie active de l'assemblage combustible",
- ang="Axial mesh number in the active part of the fuel assembly",
- statut="o",
- typ="I"),
- upper_refl=SIMP(
- fr="Nombre de mailles axiales dans le réflecteur haut",
- ang="Axial mesh number in the upper reflector",
- statut="o",
- typ="I"))),
- b_scale_local=BLOC(
- condition="scale == 'local'",
- fr="Description de la modélisation à l'échelle du locale",
- ang="Modeling description at the local scale",
- mesh_file=SIMP(
- fr="Nom du fichier décrivant le maillage",
- ang="Name of the file describing the mesh",
- statut="o",
- typ="Fichier")))
-
-
-Scenario_data = OPER(
- nom="Scenario_data",
- sd_prod=_ScenarioData,
- fr="Description du transitoire",
- ang="Transient description",
- initial_power=SIMP(
- fr="Puissance thermique initiale du cœur",
- ang="Initial thermal power of the core",
- statut="o",
- typ="R",
- val_min=0.,
- defaut=100.),
- initial_power_unit=SIMP(
- fr="Unité de la puissance thermique initiale du cœur",
- ang="Unit of the initial thermal power of the core",
- statut="o",
- typ="TXM",
- into=("% Nominal power", "W"),
- defaut="% Nominal power"),
- initial_core_inlet_temperature=SIMP(
- fr="Température initiale de l'eau à l'entrée du cœur",
- ang="Initial water temperature at the inlet of the core",
- unite="°C",
- statut="o",
- typ="R",
- val_min=0.,
- defaut=280.),
- initial_boron_concentration=SIMP(
- fr="Concentration en bore initiale",
- ang="Initial boron concentration",
- unite="ppm",
- statut="o",
- typ="R",
- val_min=0.,
- defaut=1300.),
- initial_inlet_pressure=SIMP(
- fr="Pression initiale de l'eau à l'entrée du cœur",
- ang="Initial water pressure at the inlet of the core",
- unite="bar",
- statut="o",
- typ="R",
- val_min=0.,
- defaut=160.2),
- initial_outlet_pressure=SIMP(
- fr="Pression initiale de l'eau à la sortie du cœur",
- ang="Initial water pressure at the outlet of the core",
- unite="bar",
- statut="o",
- typ="R",
- val_min=0.,
- defaut=157.2),
- initial_rod_positions=SIMP(
- fr=("Position initiale des groupes de grappes et des grappes dans le "
- "cœur sous la forme (type@nom, position) "
- "(ex. (Rodbank@RB, 62) pour le groupe de grappe RB positionné à 62 "
- "pas extraits et (Rodcluster@H08, 0) pour la grappe H08 "
- "complètement insérée)"),
- ang=("Initial position of the rod banks and the rod clusters in the "
- "core in the form (type@name, position) "
- "(e.g. (Rodbank@RB, 62) for the RB rod bank placed at 62 "
- "extracted steps and (Rodcluster@H08, 0) for the rod cluster H08 "
- "completely inserted)"),
- unite="extracted steps",
- statut="o",
- typ=Tuple(2), # TODO: Use a triplet (type, name, position) instead of a doublet
- validators=VerifTypeTuple(("TXM", "I")),
- max="**"),
- scenario_type=SIMP(
- fr="Type de transitoire à modéliser",
- ang="Type of transient to model",
- statut="o",
- typ="TXM",
- into=("RIA", )),
- b_ria=BLOC(
- condition="scenario_type == 'RIA'",
- fr="Données du transitoire 'accident de réactivité'",
- ang="Data of the 'Reactivity-initiated Accident' transient",
- ejected_rod=SIMP(
- fr="Nom de la grappe éjectée",
- ang="Name of the ejected rod cluster",
- statut="o",
- typ="TXM"),
- rod_position_program=SIMP(
- fr="Loi d'éjection à appliquer à la grappe sous la forme (temps, position)",
- ang="Ejection law to apply to the ejected rod cluster in the form (time, position)",
- unite="s, extracted steps",
- statut="o",
- typ=Tuple(2),
- validators=VerifTypeTuple(("R", "I")),
- max="**"),
- SCRAM=SIMP(
- fr="Activation/désactivation de l'arrêt automatique du réacteur",
- ang="Activation/deactivation of automatic reactor shutdown",
- statut="o",
- typ="TXM",
- into=("YES", "NO")),
- SCRAM_option=BLOC(
- condition="SCRAM == 'YES'",
- fr="Options relatives à l'arrêt automatique du réacteur",
- ang="Options relative to the automatic reactor shutdown",
- SCRAM_power=SIMP(
- fr=("Puissance thermique du cœur déclenchant un arrêt "
- "automatique du réacteur"),
- ang="Core thermal power triggering an automatic reactor shutdown",
- unite="MW",
- statut="o",
- typ="R"),
- complete_SCRAM_time=SIMP(
- fr="Temps de chute des grappes",
- ang="Rod cluster fall time",
- unite="s",
- statut="o",
- typ="R"))),
- post_processing=SIMP(
- # TODO: Give all the possible parameters depending of the physics
- fr=("Données de sortie du calcul sous la forme (paramètre@physique, format). "
- "'physique' peut valoir {physics!r} et 'format' peut valoir {formats!r}".format(
- physics=VerifPostTreatment.PHYSICS,
- formats=VerifPostTreatment.FORMATS)),
- ang=("Output computed data in function of time in the form (parameter@physic, format). "
- "'physic' can be {physics!r} and 'format' can be {formats!r})".format(
- physics=VerifPostTreatment.PHYSICS,
- formats=VerifPostTreatment.FORMATS)),
- statut="f",
- typ=Tuple(2), # TODO: Use a triplet (parameter, physic, format) instead of a doublet
- validators=VerifPostTreatment(),
- max="**"))
-
-from cata_RN_UQ import *
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 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_EDG import *
+
# sert a activer les options d incertitude dans eficas
# et a changer le convert en convertUQ
avecIncertitude=True
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)
-
+ExpressionIncertitude=creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles, scriptPosttraitement, scriptDeLancement)
-#autonome=1
-autonome=0
-if autonome :
- from Accas import *
- JdC = JDC_CATA(code="UQ");
- ExpressionIncertitude = creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles);
self.nomFrere=frere
def set_MCSimp (self, MCSimp):
- debug = 0
- if debug : print ('je passe la pour ', self, MCSimp.nom)
self.MCSimp=MCSimp
class supValeurProbabiliste(compareAutreMC):
def convert(self, valeur):
# on sort de cardProto on a une liste
valeur=valeur[0]
- MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except : return valeur
if not MCFrere : return valeur
if MCFrere== None : return valeur
if MCFrere.valeur == None : return valeur
return valeur
def verifItem(self, valeur):
- MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere)
+ except : return valeur
if not MCFrere : return valeur
if MCFrere== None : return valeur
if MCFrere.valeur == None : return valeur
def changeIntoOuput(objPostPro):
mesPostProVal=objPostPro.valeur
contexte=objPostPro.etape.parent.g_context
- for (variable,fonct) in mesPostProVal :
- if fonct == 'MED' : continue
- nomVar=variable.split('@')[0]
- phys=variable.split('@')[1]
- nomAProposer= variable+'@'+fonct
- nomBloc = 'b_physique_' + phys
- nomBlocVar = ('b_var_'+nomVar).replace( ' ','__')
- maDef=contexte['ExpressionIncertitude'].entites['Output'].entites['VariableDeSortie'].entites[nomBloc].entites[nomBlocVar].entites['VariablePosttraiteeAssociee']
- maDef.addInto(nomAProposer)
-
+ # on essaye d assurer la compatibilite du catalogue UQ pour les 2 versions du catalogue RN_EDG
+ if len(mesPostProVal[0]) == 2 :
+ for (variable,fonct) in mesPostProVal :
+ if fonct == 'MED' : continue
+ nomVar=variable.split('@')[0]
+ phys=variable.split('@')[1]
+ nomAProposer= variable+'@'+fonct
+ nomBloc = 'b_physique_' + phys
+ nomBlocVar = ('b_var_'+nomVar).replace( ' ','__')
+ maDef=contexte['ExpressionIncertitude'].entites['Output'].entites['VariableDeSortie'].entites[nomBloc].entites[nomBlocVar].entites['VariablePosttraiteeAssociee']
+ maDef.addInto(nomAProposer)
+ if len(mesPostProVal[0]) == 3 :
+ for (nomVar,phys,fonct) in mesPostProVal :
+ if '@' in nomVar : continue # Les noms des grandeurs et les associations à leurs définitions doivent être revues dans une nvlle version du cata_RN.py
+ if fonct == 'MED' : continue
+ nomAProposer= nomVar+'@'+phys+'@'+fonct
+ nomBloc = 'b_physique_' + phys
+ nomBlocVar = ('b_var_'+nomVar).replace( ' ','__')
+ maDef=contexte['ExpressionIncertitude'].entites['Output'].entites['VariableDeSortie'].entites[nomBloc].entites[nomBlocVar].entites['VariablePosttraiteeAssociee']
+ maDef.addInto(nomAProposer)
-def creeOutput(monDicoVarSortie):
+def creeOutput(monDicoVarSortie,scriptPosttraitement):
intoVariable=list(monDicoVarSortie.keys())
lesBlocs={}
Physique = SIMP (statut = "o", typ = "TXM",into = intoVariable,defaut=intoVariable[0])
lesBlocs[nomBloc] = BLOC (condition=laCondition, VariablePhysique = VariablePhysique, **lesBlocsVar)
FonctionDAggregation = SIMP(statut = 'o', typ= 'TXM', into = ('valeur à t=O', 'valeur à mi-temps', 'valeur à t final', 'valeur moyenne', 'valeur cumulée', 'valeur minimale', 'valeur maximale' ),
defaut=('Max'), max='**', homo='SansOrdreNiDoublon')
+ ScriptPosttraitement=SIMP(
+ fr="Nom du fichier Script de Postraitement",
+ ang="Postprocessing Script File",
+ statut="o",
+ typ=("FichierNoAbs", "All Files ()"), defaut=scriptPosttraitement)
VariableDeSortie = FACT ( max='**', statut ='o', Physique=Physique, **lesBlocs, FonctionDAggregation=FonctionDAggregation, Unit=Unit,Format=Format)
- output = FACT (max=1, statut ='o', VariableDeSortie=VariableDeSortie)
+ output = FACT (max=1, statut ='o', VariableDeSortie=VariableDeSortie, ScriptPosttraitement=ScriptPosttraitement)
return output
-def creeOperExpressionIncertitude(monDicoVarDeter, monDicoVarSortie):
+def creeOperExpressionIncertitude(monDicoVarDeter, monDicoVarSortie,scriptPosttraitement, scriptDeLancement ):
listeDesVariablesPossibles = list(monDicoVarDeter.keys())
#monOutput = creeOutput(monDicoVarSortie)
objectName = SIMP ( statut = "f", typ = 'TXM', into=[], fenetreIhm='menuDeroulant', homo='constant' ) # on ne met pas [] pour la projection XSD, intoXML=?
# 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",)}, op_init=definitIntoOuput,
- UncertaintyTool = SIMP ( statut = "o", typ = "TXM", into = ['Uranie', 'OpenTurns'], defaut='Uranie',position='global'),
+ UncertaintyTool = SIMP ( statut = "o", typ = "TXM", into = ['Uranie', 'OpenTurns'], defaut='OpenTurns',position='global'),
Input = FACT( max=1, statut ='o',
VariableProbabiliste = FACT ( max='**', statut ='cache',
fr = "Variable probabiliste",
EmpiricalStandardDeviation = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes',
fr = "Ecart-type empirique",
ang = "Empirical standard deviation",),
- EmpiricalQuantile = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes',
- fr = "Quantile empirique",
- ang = "Empirical quantile",),
+ EmpiricalQuantile = SIMP ( statut = "o", typ = 'TXM', into = ( 'no', ), defaut = 'no', #into = ( 'yes', 'no' ),
+ fr = "Quantile empirique (Non encore implémenté)",
+ ang = "Empirical quantile (Not Yet Implemented)",),
BlocEmpiricalQuantileSettings = BLOC ( condition = " EmpiricalQuantile in ( 'yes', ) ",
EmpiricalQuantile_Order = SIMP ( statut = "o", typ = 'R', defaut = 0.95,
val_min = 0.0, val_max = 1.0,
Methode = SIMP( statut = "o", typ = "TXM", max=1, into = ('SRS', 'Sobol'), defaut='Sobol'),
), # fin UraniePropagation
), # fin Propagation
- Output=creeOutput(monDicoVarSortie),
+ Output=creeOutput(monDicoVarSortie,scriptPosttraitement),
Execution = FACT (max=1, statut ='o',
bloc_OT = BLOC (condition = 'UncertaintyTool == "OpenTurns"',
ExecutionMode = SIMP ( statut = "o", typ = "TXM", into = ['desktop', 'cluster']),
- NbOfProcs = SIMP ( statut = 'o', typ ="I" , defaut = 1, val_min = 1),
- NbDeBranches = SIMP ( statut = "o", typ = "I", val_min = 0, fr='nb d evaluations simultanees'),
- JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_rn_job'),
+ NbDeBranches = SIMP ( statut = "o", typ = "I", val_min = 0, fr='nb d evaluations Persalys simultanees'),
bloc_OT_local = BLOC (condition = 'ExecutionMode == "desktop"',
+ JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_rn_job'),
ResourceName = SIMP ( statut = 'o', typ ="TXM", defaut ='localhost'),
Login = SIMP ( statut = 'o', typ ="TXM", defaut ='C65845'), #TODO
# WorkDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/C65845_workingdir_uncertainty'), #TODO: Login + NonExistent
WorkDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/C65845_workingdir_uncertainty'), #TODO: Login + NonExistent
# ResultDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/idefix_rn_job'), #TODO: JobName
ResultDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/idefix_rn_job'), #TODO: JobName
+ ScriptDeLancement=SIMP( statut="o", typ=("FichierNoAbs", "All Files ()"), defaut=scriptDeLancement,
+ fr="Nom du fichier script de lancement", ang="script File to launch",),
),
bloc_OT_cluster = BLOC (condition = 'ExecutionMode == "cluster"',
+ MultiJobStudy = SIMP ( statut = "o", typ = bool, defaut=False,fr='Si True, un job est soumis pour chaque évaluation de branche'),
+ NbOfProcs = SIMP ( statut = 'o', typ ="I" , defaut = 1, val_min = 1, fr='Equivaut au nombre de tasks SLURM affectées à chaque job'),
+ JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_rn_job'),
ResourceName = SIMP ( statut = 'o', typ ="TXM", defaut ='gaia'),
Login = SIMP( statut = 'o', typ ="TXM", defaut ='C65845'),
WorkDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/scratch/C65845/workingdir/persalys_light'), #TODO: Login
# WorkDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/scratch/C65845/workingdir/persalys_light'), #TODO: Login
ResultDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/idefix_rn_job'), #TODO: JobName
# ResultDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/idefix_rn_job'), #TODO: JobName
- MultiJobStudy = SIMP ( statut = "o", typ = bool, defaut=False),
+ Consigne = SIMP(statut="o", homo="information", typ="TXM",
+ defaut="Le chemin d'accès au script de lancement est celui utilisé par les machines du cluster."),
+ ScriptDeLancement=SIMP( statut="o", typ=("FichierNoAbs", "All Files ()"), defaut=scriptDeLancement,
+ fr="Nom du fichier script de lancement", ang="script File to launch",),
),
),
bloc_Uranie = BLOC (condition = 'UncertaintyTool == "Uranie"',
--- /dev/null
+# Exemple de script pour lire la sortie csv du banc
+#
+# Lecture des valeurs dans le csv et renvoi de la valeur après application de la fonction d'agragation max,min et moy
+
+#To get the history in python
+#print('\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())]))
+
+def vMax(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(max, 0, arrayNx2[:,1]).item()
+
+def vMin(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(min, 0, arrayNx2[:,1]).item()
+
+def vMean(arrayNx2):
+ import numpy as np
+ import statistics
+
+ return np.apply_along_axis(statistics.mean, 0, arrayNx2[:,1]).item()
+
+def vSum(arrayNx2):
+ import numpy as np
+
+ return np.apply_along_axis(sum, 0, arrayNx2[:,1]).item()
+
+def vInitialTime(arrayNx2):
+ import numpy as np
+
+ #Dates on first column, Values on second one
+ timeColumn= arrayNx2[:,0]
+ # Tmin=np.apply_along_axis(min, 0, timeColumn)
+ # assert(arrayNx2[0,0]==Tmin)
+ idxTmin = timeColumn.argmin()
+ assert(idxTmin==0)
+
+ valTmin= arrayNx2[idxTmin][1].item()
+
+ return valTmin
+
+def vFinalTime(arrayNx2):
+ import numpy as np
+
+ #Dates on first column, Values on second one
+ timeColumn= arrayNx2[:,0]
+ # Tmax=np.apply_along_axis(max, 0, timeColumn)
+ # assert(arrayNx2[timeColumn.size,0]==Tmax)
+ idxTmax = timeColumn.argmax()
+ idxMax=timeColumn.size-1
+ assert(idxTmax==idxMax)
+
+ valTmax= arrayNx2[idxTmax][1].item()
+
+ return valTmax
+
+def vHalfTime(arrayNx2):
+ import numpy as np
+
+ #Dates on first column, Values on second one
+ timeColumn= arrayNx2[:,0]
+ Tmin=np.apply_along_axis(min, 0, timeColumn)
+ Tmax=np.apply_along_axis(max, 0, timeColumn)
+
+ Thalf=(Tmax-Tmin)/2+Tmin
+ idxThalf = (np.abs(timeColumn-Thalf)).argmin()
+ valThalf= arrayNx2[idxThalf][1].item()
+
+ return valThalf
+
+def get_result_from_csv(variableName:str, functionList, filename:str=None, delimiter=','):
+ from csv import reader
+ import numpy as np
+
+ transientName = 'Transient duration'
+
+ #ex: file_csv = "Fuel temperature@Thermalhydraulics@MAX.csv"
+ if filename == None: filename = variableName+'.csv'
+
+ with open(filename, "r") as csv_file:
+ csv_reader = reader(csv_file, delimiter=delimiter)
+ header = next(csv_reader)
+ header_transient_name=header[1]
+ header_variable_name=header[2]
+ if header_variable_name != variableName:
+ print(sys.stderr,"The variable name {} differs from the file's header one {}".format(variableName, header_variable_name))
+ return -1 #TODO Exception ?
+ if header_transient_name != transientName:
+ print(sys.stderr,"The transient duration name {} differs from the file's header one {}".format(transientName, header_transient_name))
+ return -1 #TODO Exception ?
+
+ date_value_array=np.loadtxt(filename, delimiter = delimiter, skiprows = 1)[:,1:3]
+ valList=[]
+ for func in functionList:
+ valList.append(func(date_value_array))
+ return valList
+
