]> SALOME platform Git repositories - tools/eficas.git/commitdiff
Salome HOME
pour cafe croissant
authorPASCALE NOYRET <pascale.noyret@edf.fr>
Wed, 12 Jan 2022 13:54:07 +0000 (14:54 +0100)
committerEric Fayolle <eric.fayolle@edf.fr>
Fri, 8 Apr 2022 08:33:53 +0000 (10:33 +0200)
Efi2Xsd/AccasXsd.py
InterfaceQT4/configuration.py
ReacteurNumerique/cata_RN_EDG_Unite.py [new file with mode: 0644]

index 5d8e273091c7d444cfc7549df24561d774985b93..36cbda21fb624089c3a524baee84af1054e0837d 100755 (executable)
@@ -541,6 +541,7 @@ class X_compoFactoriseAmbigu(X_definition):
           return
         leNomDuTypePyxb  = mcRef.definitNomDuTypePyxb(forceACreer=True)
         if debug : print ('nomMC', nomMC)
+        i=0
         for mc in self.entites[nomMC]:
             if debug : print ('------------', mc)
             # on laisse dansFactorisation a False car ce n est pas comme une fusion de bloc 
@@ -946,7 +947,6 @@ class X_SIMP (X_definition):
            return
 
         if self.avecBlancs and self.max > 1 :
-           #print ('je suis avec blanc pour ', self.nom)
            self.dumpSpecifiqueTexteAvecBlancs(minOccurs,multiple)
            return
 
@@ -1170,7 +1170,6 @@ class X_SIMP (X_definition):
         # il faut gerer les types tuple et fichier
         # on ne paut pas tester le type qui depend du cataloge
         if hasattr(self.type[0], 'typElt') : 
-            #print ('je suis une Matrice de ' ,dictNomsDesTypes[self.type[0].typElt]) 
             self.suisUneMatrice = True
             # on presume que le type de l elt est un ASSD
             if self.type[0].typElt not in dictNomsDesTypes.keys(): return 'xs:string'
@@ -1184,7 +1183,13 @@ class X_SIMP (X_definition):
             leType=self.validators.typeDesTuples[0]
             enRetour=[]
             for i in range(self.type[0].ntuple):
-                enRetour.append(dictNomsDesTypes[self.validators.typeDesTuples[i]])
+                # Attention, si plusieurs validators on a des soucis
+                # a Reprendre
+                typeATraduire = self.validators.typeDesTuples[i]
+                if not (typeATraduire in list(dictNomsDesTypes.keys())) :
+                   enRetour.append('xs:string')
+                else : 
+                    enRetour.append(dictNomsDesTypes[self.validators.typeDesTuples[i]])
             return enRetour
             #typeATraduire=leType
         else :
index 4c55cd7f0f22e9a57ff12bce2e4c6925fa8eb508..cae7add4c84b3b6567ce090ce5fa877272078e94 100644 (file)
@@ -80,6 +80,9 @@ class configBase(object):
         #Particularite des schemas MAP
         if hasattr(self,'make_ssCode'): self.make_ssCode(self.ssCode)
 
+        #if self.appliEficas: self.parent=appliEficas.top
+        #else:         self.parent=None
+
         if not os.path.isdir(self.savedir) :
            self.savedir=os.path.join(os.path.expanduser("~"),'.config/Eficas',self.code)
 
@@ -137,6 +140,8 @@ class configBase(object):
         self.withXSD=False
         self.afficheIhm=True
 
+        self.afficheUQ=False
+        #self.afficheUQ=True
 
 
 
@@ -149,7 +154,7 @@ class configBase(object):
             prefsCode=__import__(name)
         except :
             self.catalogues=[]
-            print ('pas de fichier de prefs')
+            #print ('pas de fichier de prefs')
             return
         for k in dir(prefsCode):
             if (k[0:1] != "__" and k[-1:-2] !='__'):
diff --git a/ReacteurNumerique/cata_RN_EDG_Unite.py b/ReacteurNumerique/cata_RN_EDG_Unite.py
new file mode 100644 (file)
index 0000000..de2d268
--- /dev/null
@@ -0,0 +1,811 @@
+# -*- 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=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 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
+
+class Tuple:
+    """Organize the data into a fixed size tuple.
+
+    Warnings
+    --------
+    This class respect the EFICAS conventions.
+    """
+
+    def __init__(self, ntuple):
+        self.ntuple = ntuple
+
+    def __convert__(self, valeur):
+        if len(valeur) != self.ntuple:
+            return None
+        return valeur
+
+    def info(self):  # pylint: disable=missing-function-docstring
+        return "Tuple de %s elements" % self.ntuple
+
+
+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 VerifNeutLib(VerifTypeTuple):
+    """Validate the data comming from ``Model_data.b_neutro_compo.library_map``.
+
+    Warnings
+    --------
+    This class respect the EFICAS conventions.
+    """
+    # pylint: disable=invalid-name
+    # pylint: disable=no-self-use
+    # pylint: disable=missing-function-docstring
+
+    def __init__(self):
+        super().__init__((_Assembly, "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))
+        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
+        a, v = valeur
+        if isinstance(a, _Assembly):
+            ok += 1
+        if isinstance(v, (bytes, str)):
+            ok += 1
+        if ok == len(self.typeDesTuples):
+            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,
+    assembly_type=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("UOX", "MOX", "REF"),
+        fr="Type d'élément cœur (assemblage combustible ou réflecteur",
+        ang="Type of the core element (fuel assembly or reflector"),
+    description=BLOC(
+        condition="assembly_type != 'REF'",
+        assembly_width=SIMP(
+            statut="o",
+            typ="R",
+            unite="m",
+            fr="Pas inter-assemblage dans le cœur",
+            ang="Fuel assembly pitch in the core"),
+        fuel_density=SIMP(
+            statut="o",
+            typ="R",
+            defaut=0.95,
+            unite="g/cm3",
+            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")),
+        radial_description=FACT(
+            statut="o",
+            clad_outer_radius=SIMP(
+                statut="o",
+                typ="R",
+                unite="m",
+                fr="Rayon externe de la gaine des crayons combustible",
+                ang="Clad external radius of the fuel pins"),
+            guide_tube_outer_radius=SIMP(
+                statut="o",
+                typ="R",
+                unite="m",
+                fr="Rayon externe des tubes guides",
+                ang="Clad external radius of the guide tubes"),
+            fuel_rod_pitch=SIMP(
+                statut="o",
+                typ="R",
+                unite="m",
+                fr="Pas inter-crayon dans l'assemblage",
+                ang="Fuel pin pitch in the assembly"),
+            nfuel_rods=SIMP(
+                statut="o",
+                typ="I",
+                fr="Nombre de crayons combustibles dans l'assemblage",
+                ang="Number of fuel pins in the assembly"),
+            fr="Description radiale de l'assemblage combustible",
+            ang="Fuel assembly radial description"),
+        axial_description=FACT(
+            statut="o",
+            active_length_start=SIMP(
+                statut="o",
+                typ="R",
+                unite="m",
+                fr="Altitude basse de la partie active",
+                ang="Lower altitude of the active part"),
+            active_length_end=SIMP(
+                statut="o",
+                typ="R",
+                unite="m",
+                fr="Altitude haute de la partie active",
+                ang="Upper altitude of the active part"),
+            fr="Description axiale de l'assemblage combustible",
+            ang="Fuel assembly axial description"),
+        grids=FACT(
+            statut="o",
+            mixing=FACT(
+                statut="o",
+                positions=SIMP(
+                    statut="f",
+                    typ="R",
+                    max="**",
+                    unite="m",
+                    fr="Altitude basse de la grille",
+                    ang="Grid lower altitude"),
+                size=SIMP(
+                    statut="o",
+                    typ="R",
+                    unite="m",
+                    fr="Hauteur de la grille",
+                    ang="Grid height"),
+                fr="Description des grilles de mélange",
+                ang="Mixing grids description"),
+            non_mixing=FACT(
+                statut="o",
+                positions=SIMP(
+                    statut="f",
+                    typ="R",
+                    max="**",
+                    unite="m",
+                    fr="Altitude basse de la grille",
+                    ang="Grid lower altitude"),
+                size=SIMP(
+                    statut="o",
+                    typ="R",
+                    unite="m",
+                    fr="Hauteur de la grille",
+                    ang="Grid height"),
+                fr="Description des grilles de maintien",
+                ang="Holding grids description"),
+            fr="Description des grilles",
+            ang="Grids description"),
+        fr="Description d'un assemblage combustible",
+        ang="Fuel assembly description"),
+    fr="Description d'un élément du cœur",
+    ang="Core element description")
+
+
+# TODO: Define the names of the possible compositions (Black, Grey, B4C, Hafnium and Pyrex)
+RodBank = OPER(
+    nom="RodBank",
+    sd_prod=_RodBank,
+    rod_type=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("homogeneous", "heterogeneous"),
+        fr="Type de grappes absorbantes",
+        ang="Type of rod clusters"),
+    description_HOM=BLOC(
+        condition="rod_type == 'homogeneous'",
+        rod_composition=SIMP(
+            statut="o",
+            typ="TXM",
+            fr="Type de matériau absorbant des grappes absorbantes",
+            ang="Absorbing material type of the rod clusters"),
+        fr="Description d'un groupe de grappes absorbantes homogènes axialement",
+        ang="Axially homogeneous rod bank description"),
+    description_HET=BLOC(
+        condition="rod_type == 'heterogeneous'",
+        bottom_composition=SIMP(
+            statut="o",
+            typ="TXM",
+            fr="Type de matériau absorbant dans la partie basse des grappes absorantes",
+            ang="Absorbing material type in the lower part of the rod clusters"),
+        splitting_heigh=SIMP(
+            statut="o",
+            typ="R",
+            unite="m",
+            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")),
+        upper_composition=SIMP(
+            statut="o",
+            typ="TXM",
+            fr="Type de matériau absorbant dans la partie haute des grappes absorantes",
+            ang="Absorbing material type in the upper part of the rod clusters"),
+        fr="Description d'un groupe de grappes absorbantes hétérogène axialement",
+        ang="Axially heterogeneous rod bank description"),
+    step_height=SIMP(
+        statut="o",
+        typ="R",
+        unite="m",
+        fr="Hauteur d'un pas",
+        ang="Step height"),
+    nsteps=SIMP(
+        statut="o",
+        typ="I",
+        fr="Nombre de pas du groupe de grappes",
+        ang="Rod bank steps number"),
+    fr="Description d'un groupe de grappes absorbantes",
+    ang="Rod bank description")
+
+
+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,
+            xaxis=SIMP(
+                statut="o",
+                typ="TXM",
+                min=i + 2,
+                max=i + 2,
+                defaut=def_xaxis[i],
+                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"),
+            yaxis=SIMP(
+                statut="o",
+                typ="TXM",
+                min=i + 2,
+                max=i + 2,
+                defaut=def_yaxis[i],
+                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"),
+            assembly_map=SIMP(
+                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",)),
+                    defaut=(i + 2) * [(i + 2) * ["."]],
+                    coloree=True),
+                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")),
+            rod_map=SIMP(
+                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) * ["."]],
+                fr="Répartition radiale des groupes de grappes dans le cœur",
+                ang="Rod banks radial repartition in the core"),
+            BU_map=SIMP(
+                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) * ["."]],
+                fr="Taux de combustion moyen des assemblages combustibles en GW.j/t",
+                ang="Average burnup of the fuel assemblies in GW.d/t"),
+            fr="Description radiale du cœur",
+            ang="Core radial description")
+    return dico
+
+
+Techno_data = OPER(
+    nom="Techno_data",
+    sd_prod=_TechnoData,
+    assembly_list=SIMP(
+        statut="o",
+        typ=_Assembly,
+        min=1,
+        max="**",
+        fr="Sélection des assemblages combustible",
+        ang="Fuel assemblies selection"),
+    rodbank_list=SIMP(
+        statut="o",
+        typ=_RodBank,
+        min=0,
+        max="**",
+        fr="Sélection des groupes de grappes",
+        ang="Rod banks selection"),
+    radial_description=FACT(
+        statut="o",
+        nb_assembly=SIMP(
+            statut="o",
+            typ="I",
+            into=list(range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS)),
+            fr="Nombre d'éléments combustible sur la tranche du cœur",
+            ang="Number of fuel elements on one side of the core"),
+        **(gen_assembly_maps())),
+    axial_description=FACT(
+        statut="o",
+        lower_refl_size=SIMP(
+            statut="o",
+            typ="R",
+            unite="m",
+            fr="Hauteur du réflecteur axial bas",
+            ang="Height of bottom axial reflector"),
+        upper_refl_size=SIMP(
+            statut="o",
+            typ="R",
+            unite="m",
+            fr="Hauteur du réflecteur axial haut",
+            ang="Height of top axial reflector")),
+    nominal_power=SIMP(
+        statut="o",
+        typ="R",
+        unite="W",
+        fr="Puissance thermique nominale du cœur",
+        ang="Nominal thermal power of the core"),
+    Fuel_power_fraction=SIMP(
+        statut="o",
+        typ="R",
+        defaut=0.974,
+        fr="Fraction de la puissance dissipée dans le combustible",
+        ang="Power fraction dissipated in the fuel"),
+    by_pass=SIMP(
+        statut="o",
+        typ="R",
+        defaut=0.07,
+        fr="Fraction du débit de bypass cœur",
+        ang="Bypass core flow fraction"),
+    core_volumic_flowrate=SIMP(
+        statut="o",
+        typ="R",
+        unite="m3/h",
+        fr="Débit volumique cœur",
+        ang="Core volume flowrate"),
+    fr="Description technologique du cœur",
+    ang="Core technological description")
+
+
+# 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,
+    physics=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("Neutronics", "Thermalhydraulics"),
+        fr="Sélection de la physique du modèle",
+        ang="Physic model selection"),
+    scale=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("system", "component", "local"),
+        fr="Sélection de l'échelle du modèle",
+        ang="Scale model selection"),
+    b_neutro_compo=BLOC(
+        condition="physics == 'Neutronics' and scale == 'component'",
+        # TODO: Split this in two: fuel assemblies libraries and reflector libraries)
+        # TODO: Use a triplet (assembly, filename, pattern) instead of a doublet for the fuel assemblies libraries
+        # TODO: Use a doublet (reflector, filename) for the reflector libraries
+        library_map=SIMP(
+            statut="f",
+            typ=Tuple(2),
+            validators=VerifNeutLib(),
+            max="**",
+            fr=("Association des éléments du cœur aux bibliothèques neutroniques "
+                "sous la forme (assemblage combustible, nom du fichier@pattern) "
+                "pour les bibliothèques assemblages et sous la forme "
+                "(réflecteur, nom du fichier) pour les bibliothèques réflecteur"),
+            ang=("Association between the core elements and the neutronic libraries "
+                 "in the form (fuel assembly, filename@pattern) for the fuel assembly "
+                 "libraries and in the form of (reflector, filename) for the "
+                 "reflector libraries")),
+        code=SIMP(
+            statut="o",
+            typ="TXM",
+            into=("COCAGNE", "APOLLO3"),
+            fr="Sélection du code de neutronique cœur",
+            ang="Core neutronic code selection"),
+        # TODO: Implement the *4x4* mesh
+        radial_meshing=FACT(
+            statut="o",
+            flux_solver=SIMP(
+                statut="o",
+                typ="TXM",
+                into=("subdivision", "pin-by-pin"),
+                fr="Type de maillage radial du solveur de flux",
+                ang="Radial mesh type for the flux solver"),
+            b_flux_subdivision=BLOC(
+                condition="flux_solver == 'subdivision'",
+                flux_subdivision=SIMP(
+                    statut="o",
+                    typ="I",
+                    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")),
+                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")),
+            feedback_solver=SIMP(
+                statut="o",
+                typ="TXM",
+                into=("subdivision", "pin-by-pin"),
+                fr="Type de maillage radial du solveur de contre-réaction",
+                ang="Radial mesh type for the feedback solver"),
+            b_feedback_subdivision=BLOC(
+                condition="feedback_solver == 'subdivision'",
+                feedback_subdivision=SIMP(
+                    statut="o",
+                    typ="I",
+                    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")),
+                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")),
+            fr="Maillage radial du cœur",
+            ang="Core radial meshing"),
+        fr="Description de la modélisation neutronique à l'échelle du composant",
+        ang="Neutronic modeling description at the component scale"),
+    b_thermo_compo=BLOC(
+        condition="physics == 'Thermalhydraulics' and scale == 'component'",
+        code=SIMP(
+            statut="o",
+            typ="TXM",
+            into=("THYC", "CATHARE3", "FLICA4"),
+            fr="Sélection du code de thermohydraulique cœur",
+            ang="Core thermalhydraulic code selection"),
+        radial_meshing=FACT(
+            statut="o",
+            fluid=SIMP(
+                statut="o",
+                typ="TXM",
+                into=("subdivision", "subchannel"),
+                fr="Méthode de maillage radial",
+                ang="Radial meshing method"),
+            b_fluid_subdivision=BLOC(
+                condition="fluid == 'subdivision'",
+                fluid_subdivision=SIMP(
+                    statut="o",
+                    typ="I",
+                    fr="Nombre de mailles radiales dans les assemblages combustibles",
+                    ang="Radial mesh number in the fuel assemblies"),
+                fr="Données spécifiques au maillage radial par subdivision",
+                ang="Specific data for the radial meshing by subdivision"),
+            pellet=SIMP(
+                statut="o",
+                typ="I",
+                fr="Nombre de mailles radiales dans la pastille combustible",
+                ang="Radial mesh number in the fuel pellet"),
+            clad=SIMP(
+                statut="o",
+                typ="I",
+                fr="Nombre de mailles radiales dans la gaine des crayons combustibles",
+                ang="Radial mesh number in the clad of the fuel pins"),
+            fr="Description du maillage radial thermohydraulique à l'échelle du composant",
+            ang="Thermalhydraulic radial meshing description at the component scale"),
+        fr="Description de la modélisation thermohydraulique à l'échelle du composant",
+        ang="Thermalhydraulic modeling description at the component scale"),
+    b_scale_compo=BLOC(
+        condition="scale == 'component'",
+        axial_meshing=FACT(
+            statut="o",
+            lower_refl=SIMP(
+                statut="o",
+                typ="I",
+                fr="Nombre de mailles axiales dans le réflecteur bas",
+                ang="Axial mesh number in the lower reflector"),
+            fuel=SIMP(
+                statut="o",
+                typ="I",
+                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"),
+            upper_refl=SIMP(
+                statut="o",
+                typ="I",
+                fr="Nombre de mailles axiales dans le réflecteur haut",
+                ang="Axial mesh number in the upper reflector"),
+            fr="Maillage axial du cœur",
+            ang="Core axial meshing"),
+        fr="Description de la modélisation à l'échelle du composant",
+        ang="Modeling description at the component scale"),
+    b_scale_local=BLOC(
+        condition="scale == 'local'",
+        mesh_file=SIMP(
+            statut="o",
+            typ="Fichier",
+            fr="Nom du fichier décrivant le maillage",
+            ang="Name of the file describing the mesh")),
+    fr="Description de la modélisation physique",
+    ang="Physical modeling description")
+
+
+Scenario_data = OPER(
+    nom="Scenario_data",
+    sd_prod=_ScenarioData,
+    initial_power=SIMP(
+        statut="o",
+        typ="R",
+        val_min=0.,
+        defaut=100.,
+        fr="Puissance thermique initiale du cœur",
+        ang="Initial thermal power of the core"),
+    initial_power_unit=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("% Nominal power", "W"),
+        defaut="% Nominal power",
+        fr="Unité de la puissance thermique initiale du cœur",
+        ang="Unit of the initial thermal power of the core"),
+    initial_core_inlet_temperature=SIMP(
+        statut="o",
+        typ="R",
+        val_min=0.,
+        defaut=280.,
+        unite="°C",
+        fr="Température initiale de l'eau à l'entrée du cœur",
+        ang="Initial water temperature at the inlet of the core"),
+    initial_boron_concentration=SIMP(
+        statut="o",
+        typ="R",
+        val_min=0.,
+        defaut=1300.,
+        unite="ppm",
+        fr="Concentration en bore initiale",
+        ang="Initial boron concentration"),
+    initial_inlet_pressure=SIMP(
+        statut="o",
+        typ="R",
+        val_min=0.,
+        defaut=160.2,
+        unite="bar",
+        fr="Pression initiale de l'eau à l'entrée du cœur",
+        ang="Initial water pressure at the inlet of the core"),
+    initial_outlet_pressure=SIMP(
+        statut="o",
+        typ="R",
+        val_min=0.,
+        defaut=157.2,
+        unite="bar",
+        fr="Pression initiale de l'eau à la sortie du cœur",
+        ang="Initial water pressure at the outlet of the core"),
+    initial_rod_positions=SIMP(
+        statut="o",
+        typ=Tuple(2),  # TODO: Use a triplet (type, name, position) instead of a doublet
+        validators=VerifTypeTuple(("TXM", "I")),
+        max="**",
+        unite="extracted steps",
+        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)")),
+    scenario_type=SIMP(
+        statut="o",
+        typ="TXM",
+        into=("RIA", ),
+        fr="Type de transitoire à modéliser",
+        ang="Type of transient to model"),
+    b_ria=BLOC(
+        condition="scenario_type == 'RIA'",
+        ejected_rod=SIMP(
+            statut="o",
+            typ="TXM",
+            fr="Nom de la grappe éjectée",
+            ang="Name of the ejected rod cluster"),
+        rod_position_program=SIMP(
+            statut="o",
+            typ=Tuple(2),
+            validators=VerifTypeTuple(("R", "I")),
+            max="**",
+            unite="s, extracted steps",
+            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)"),
+        SCRAM=SIMP(
+            statut="o",
+            typ="TXM",
+            into=("YES", "NO"),
+            fr="Activation/désactivation de l'arrêt automatique du réacteur",
+            ang="Activation/deactivation of automatic reactor shutdown"),
+        SCRAM_option=BLOC(
+            condition="SCRAM == 'YES'",
+            SCRAM_power=SIMP(
+                statut="o",
+                typ="R",
+                unite="MW",
+                fr=("Puissance thermique du cœur déclenchant un arrêt "
+                    "automatique du réacteur"),
+                ang="Core thermal power triggering an automatic reactor shutdown"),
+            complete_SCRAM_time=SIMP(
+                statut="o",
+                typ="R",
+                unite="s",
+                fr="Temps de chute des grappes",
+                ang="Rod cluster fall time")),
+        fr="Données du transitoire 'accident de réactivité'",
+        ang="Data of the 'Reactivity-initiated Accident' transient"),
+    post_processing=SIMP(
+        statut="f",
+        typ=Tuple(2),  # TODO: Use a triplet (parameter, physic, format) instead of a doublet
+        validators=VerifPostTreatment(),
+        max="**",
+        # 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))),
+    fr="Description du transitoire",
+    ang="Transient description")