2. Syntaxe#

/ acou_harmo
/ dyna_harmo
/ dyna_trans
/ harm_gene
/ tran_gene = DYNA_VIBRA(
    ◇ reuse = <objet de RESULTAT>,
    ◆ BASE_CALCUL = / "GENE",
                    / "PHYS",
    ◆ TYPE_CALCUL = / "HARM",
                    / "TRAN",
    # Si: equal_to("BASE_CALCUL", 'PHYS')
        ◇ MODELE = modele,
        ◇ CHAM_MATER = cham_mater,
        ◇ CARA_ELEM = cara_elem,
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
        ◆ MATR_MASS = matr_asse_depl_r,
        ◆ MATR_RIGI = matr_asse_depl_r,
        ◇ MATR_AMOR = matr_asse_depl_r,
        ◇ OBSERVATION = _F(
             ◇ TITRE = text,
             ◇ OBSE_ETAT_INIT = / "NON",
                                / "OUI" (par défaut),
             ◇ EVAL_CHAM = / "MAX",
                           / "MAXI_ABS",
                           / "MIN",
                           / "MINI_ABS",
                           / "MOY",
                           / "VALE" (par défaut),
             ◆ / NOM_CMP = text,
               / NOM_VARI = text,
             ◇ EVAL_CMP = / "FORMULE",
                          / "VALE" (par défaut),
             ◇ INST = float,
             ◇ LIST_INST = listr8,
             ◇ PAS_OBSE = int,
             ◇ CRITERE = / "ABSOLU",
                         / "RELATIF" (par défaut),
             ◆ NOM_CHAM = / "ACCE",
                          / "DEPL",
                          / "VITE",
             # Si: (equal_to("EVAL_CMP", 'FORMULE'))
                 ◆ FORMULE = formule,
             # Si: is_in("NOM_CHAM", ('DEPL','VITE','ACCE','TEMP','FORC_NODA','CONT_NOEU','DEPL_ABSOLU','VITE_ABSOLU','ACCE_ABSOLU'))
                 ◆ / TOUT = "OUI" (ou non renseigné),
                   / NOEUD = no,
                   / GROUP_NO = grno,
                   / GROUP_MA = grma,
                   / MAILLE = ma,
             # Si: is_in("NOM_CHAM", ('SIEF_ELGA','EPSI_ELGA','VARI_ELGA'))
                 ◆ / TOUT = "OUI" (ou non renseigné),
                   / GROUP_MA = grma,
                   / MAILLE = ma,
                 ◇ EVAL_ELGA = / "MAX",
                               / "MIN",
                               / "VALE" (par défaut),
                 # Si: (equal_to("EVAL_ELGA", 'VALE'))
                     ◆ POINT = int,
                     ◇ SOUS_POINT = int,
             # Si: (equal_to("NOM_CHAM", 'CONT_ELEM'))
                 ◆ / TOUT = "OUI" (ou non renseigné),
                   / GROUP_MA = grma,
                   / MAILLE = ma,
             # Si: (equal_to("CRITERE", 'RELATIF'))
                 ◇ PRECISION = float (défaut: 1e-06),
             # Si: (equal_to("CRITERE", 'ABSOLU'))
                 ◆ PRECISION = float,
          ),
        ◇ AMOR_MODAL = _F(
             ◇ / AMOR_REDUIT = float,
               / LIST_AMOR = listr8,
             ◆ MODE_MECA = mode_meca,
             ◇ NB_MODE = int,
          ),
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
        ◆ MATR_MASS = matr_asse_gene_r,
        ◆ MATR_RIGI = matr_asse_gene_r,
          / MATR_AMOR = matr_asse_gene_r,
        ◇ / AMOR_MODAL = _F(
               ◇ / AMOR_REDUIT = float,
                 / LIST_AMOR = listr8,
            ),
        ◇ VITESSE_VARIABLE = / "NON" (par défaut),
                             / "OUI",
        # Si: equal_to("VITESSE_VARIABLE", 'OUI')
            ◆ MATR_GYRO = matr_asse_gene_r,
            ◆ VITE_ROTA = fonction / formule,
            ◇ MATR_RIGY = matr_asse_gene_r,
            ◇ ACCE_ROTA = fonction / formule,
        # Si: equal_to("VITESSE_VARIABLE", 'NON')
            ◇ VITE_ROTA = float (défaut: 0.0),
    # Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'PHYS')
        ◆ MATR_MASS = matr_asse_depl_r / matr_asse_pres_c,
        ◆ MATR_RIGI = matr_asse_depl_c / matr_asse_depl_r / matr_asse_pres_c,
          / MATR_AMOR = matr_asse_depl_r / matr_asse_pres_c,
        ◇ / AMOR_MODAL = _F(
               ◇ / AMOR_REDUIT = float,
                 / LIST_AMOR = listr8,
            ),
        ◇ MATR_IMPE_PHI = matr_asse_depl_r,
        # Si: exists("MATR_AMOR") and exists("MATR_IMPE_PHI")
            ◇ AMOR_FLUI = / "NON",
                          / "OUI" (par défaut),
    # Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'GENE')
        ◆ MATR_MASS = matr_asse_gene_r,
        ◆ MATR_RIGI = matr_asse_gene_c / matr_asse_gene_r,
        ◇ MATR_AMOR = matr_asse_gene_r,
        ◇ MATR_IMPE_PHI = matr_asse_gene_r,
        ◇ AMOR_MODAL = _F(
             ◇ / AMOR_REDUIT = float,
               / LIST_AMOR = listr8,
          ),
        # Si: exists("MATR_AMOR") and exists("MATR_IMPE_PHI")
            ◇ AMOR_FLUI = / "NON",
                          / "OUI" (par défaut),
    ◇ RESULTAT = dyna_harmo / harm_gene,
    # Si: equal_to("TYPE_CALCUL", 'HARM')
        ◆ / FREQ = float,
          / LIST_FREQ = listr8,
        ◇ / NOM_CHAM = / "ACCE",
                       / "DEPL",
                       / "VITE",
          / TOUT_CHAM = "OUI" (ou non renseigné),
    # Si: equal_to("TYPE_CALCUL", 'TRAN')
        ⟐ SCHEMA_TEMPS = _F(
             # Si: equal_to("BASE_CALCUL",'GENE')
                 ◇ SCHEMA = / "ADAPT_ORDRE1",
                            / "ADAPT_ORDRE2",
                            / "DEVOGE",
                            / "DIFF_CENTRE",
                            / "ITMI",
                            / "NEWMARK",
                            / "RUNGE_KUTTA_32" (par défaut),
                            / "RUNGE_KUTTA_54",
                            / "TRBDF2",
                 # Si: equal_to("SCHEMA", 'NEWMARK')
                     ◇ BETA = float (défaut: 0.25),
                     ◇ GAMMA = float (défaut: 0.5),
                 # Si: equal_to("SCHEMA", 'RUNGE_KUTTA_54') or equal_to("SCHEMA", 'RUNGE_KUTTA_32') or equal_to("SCHEMA", 'DEVOGE')
                     ◇ TOLERANCE = float (défaut: 1e-05),
                     ◇ ALPHA = float (défaut: 0.0),
                 # Si: equal_to("SCHEMA", 'ADAPT_ORDRE1') or  equal_to("SCHEMA", 'ADAPT_ORDRE2')
                     ◇ VITE_MIN = / "MAXI",
                                  / "NORM" (par défaut),
                     ◇ COEF_MULT_PAS = float (défaut: 1.1),
                     ◇ COEF_DIVI_PAS = float (défaut: 1.3333334),
                     ◇ PAS_LIMI_RELA = float (défaut: 1e-06),
                     ◇ NB_POIN_PERIODE = int (défaut: 50),
                 # Si: is_in("SCHEMA", ('RUNGE_KUTTA_54','RUNGE_KUTTA_32','DEVOGE','ADAPT_ORDRE1','ADAPT_ORDRE2'))
                     ◇ PAS_MINI = float,
                     ◇ PAS_MAXI = float,
                     ◇ NMAX_ITER_PAS = int (défaut: 16),
             # Si: not equal_to("BASE_CALCUL",'GENE')
                 ◇ SCHEMA = / "ADAPT_ORDRE1",
                            / "ADAPT_ORDRE2",
                            / "DEVOGE",
                            / "DIFF_CENTRE",
                            / "ITMI",
                            / "NEWMARK" (par défaut),
                            / "RUNGE_KUTTA_32",
                            / "RUNGE_KUTTA_54",
                            / "WILSON",
                 # Si: equal_to("SCHEMA", 'NEWMARK')
                     ◇ BETA = float (défaut: 0.25),
                     ◇ GAMMA = float (défaut: 0.5),
                 # Si: equal_to("SCHEMA", 'WILSON')
                     ◇ THETA = float (défaut: 1.4),
                 # Si: equal_to("SCHEMA", 'RUNGE_KUTTA_54') or equal_to("SCHEMA", 'RUNGE_KUTTA_32') or equal_to("SCHEMA", 'DEVOGE')
                     ◇ TOLERANCE = float (défaut: 1e-05),
                     ◇ ALPHA = float (défaut: 0.0),
                 # Si: equal_to("SCHEMA", 'ADAPT_ORDRE1') or  equal_to("SCHEMA", 'ADAPT_ORDRE2')
                     ◇ VITE_MIN = / "MAXI",
                                  / "NORM" (par défaut),
                     ◇ COEF_MULT_PAS = float (défaut: 1.1),
                     ◇ COEF_DIVI_PAS = float (défaut: 1.3333334),
                     ◇ PAS_LIMI_RELA = float (défaut: 1e-06),
                     ◇ NB_POIN_PERIODE = int (défaut: 50),
                 # Si: is_in("SCHEMA", ('RUNGE_KUTTA_54','RUNGE_KUTTA_32','DEVOGE','ADAPT_ORDRE1','ADAPT_ORDRE2'))
                     ◇ PAS_MINI = float,
                     ◇ PAS_MAXI = float,
                     ◇ NMAX_ITER_PAS = int (défaut: 16),
          ),
        ◆ INCREMENT = _F(
             ◆ / LIST_INST = listr8,
               / PAS = float,
             # Si: exists("LIST_INST")
                 ◇ / NUME_FIN = int,
                   / INST_FIN = float,
             # Si: exists("PAS")
                 ◇ INST_INIT = float,
                 ◆ INST_FIN = float,
             ◇ VERI_PAS = / "NON",
                          / "OUI" (par défaut),
          ),
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
        ◇ ETAT_INIT = _F(
             ◇ / RESULTAT = tran_gene,
               / DEPL = vect_asse_gene,
             ◇ / VITE = vect_asse_gene,
             # Si: exists("RESULTAT")
                 ◇ / NUME_ORDRE = int,
                   / INST_INIT = float,
                 # Si: exists("INST_INIT")
                     ◇ CRITERE = / "ABSOLU",
                                 / "RELATIF" (par défaut),
                     # Si: (equal_to("CRITERE", 'RELATIF'))
                         ◇ PRECISION = float (défaut: 1e-06),
                     # Si: (equal_to("CRITERE", 'ABSOLU'))
                         ◆ PRECISION = float,
          ),
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
        ◇ ETAT_INIT = _F(
             ◆ | RESULTAT = dyna_trans,
               | DEPL = cham_no,
               | VITE = cham_no,
               | ACCE = cham_no,
             # Si: exists("RESULTAT")
                 ◇ / NUME_ORDRE = int,
                   / INST_INIT = float,
                 # Si: exists("INST_INIT")
                     ◇ CRITERE = / "ABSOLU",
                                 / "RELATIF" (par défaut),
                     # Si: (equal_to("CRITERE", 'RELATIF'))
                         ◇ PRECISION = float (défaut: 1e-06),
                     # Si: (equal_to("CRITERE", 'ABSOLU'))
                         ◆ PRECISION = float,
          ),
    # Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
        ◇ ARCHIVAGE = _F(
             ◇ PAS_ARCH = int,
             ◇ / LIST_INST = listr8,
               / INST = float,
             # Si: (exists("LIST_INST") or exists("INST"))
                 ◇ CRITERE = / "ABSOLU",
                             / "RELATIF" (par défaut),
                 # Si: (equal_to("CRITERE", 'RELATIF'))
                     ◇ PRECISION = float (défaut: 1e-06),
                 # Si: (equal_to("CRITERE", 'ABSOLU'))
                     ◆ PRECISION = float,
             ◇ CHAM_EXCLU = / "ACCE",
                            / "DEPL",
                            / "VITE",
          ),
    # Si: not equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
        ◇ ARCHIVAGE = _F(
             ◆ | PAS_ARCH = int,
               | LIST_INST = listr8,
               | INST = float,
          ),
    # Si: equal_to("BASE_CALCUL", 'PHYS')
        ◇ ENERGIE = _F(
             ◇ CALCUL = "OUI",
          ),
    # Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'PHYS')
        ◆ | EXCIT = _F(
               ◆ / VECT_ASSE = cham_no,
                 / CHARGE = char_cine_meca / char_meca,
               ◆ / FONC_MULT_C = fonction_c / formule_c,
                 / FONC_MULT = fonction / formule / nappe,
                 / COEF_MULT = float,
                 / COEF_MULT_C = complex,
               ◇ PHAS_DEG = float (défaut: 0.0),
               ◇ PUIS_PULS = int (défaut: 0),
            ),
          | EXCIT_RESU = _F(
               ◆ RESULTAT = dyna_harmo,
               ◆ COEF_MULT_C = complex,
            ),
    # Si: equal_to("TYPE_CALCUL", 'HARM') and equal_to("BASE_CALCUL", 'GENE')
        ◆ | EXCIT = _F(
               ◆ VECT_ASSE_GENE = vect_asse_gene,
               ◆ / FONC_MULT_C = fonction_c / formule_c,
                 / FONC_MULT = fonction / formule / nappe,
                 / COEF_MULT = float,
                 / COEF_MULT_C = complex,
               ◇ PHAS_DEG = float (défaut: 0.0),
               ◇ PUIS_PULS = int (défaut: 0),
            ),
          | EXCIT_RESU = _F(
               ◆ RESULTAT = harm_gene,
               ◆ COEF_MULT_C = complex,
            ),
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'PHYS')
        ◇ EXCIT = _F(
             ◆ / VECT_ASSE = cham_no,
               / CHARGE = char_cine_meca / char_meca,
             ◇ / FONC_MULT = fonction / formule / nappe,
               / COEF_MULT = float,
             ◇ / ACCE = fonction / formule / nappe,
             ◇ & VITE = fonction / formule / nappe,
               & ◆ DEPL = fonction / formule / nappe,
             ◇ MULT_APPUI = / "NON" (par défaut),
                            / "OUI",
             # Si: equal_to("MULT_APPUI", 'OUI')
                 ◇ DIRECTION = float,
                 ◇ GROUP_NO = grno,
          ),
        ◇ MODE_STAT = mode_meca,
        ◇ EXCIT_RESU = _F(
             ◆ RESULTAT = dyna_trans,
             ◆ COEF_MULT = float,
          ),
    # Si: equal_to("TYPE_CALCUL", 'TRAN') and equal_to("BASE_CALCUL", 'GENE')
        ◇ EXCIT = _F(
             ◆ / VECT_ASSE_GENE = vect_asse_gene,
               / NUME_ORDRE = int,
             ◆ / FONC_MULT = fonction / formule / nappe,
               / COEF_MULT = float,
               / ACCE = fonction / formule / nappe,
             ◇ & VITE = fonction / formule / nappe,
               & ◆ DEPL = fonction / formule / nappe,
             ◇ / MULT_APPUI = "OUI" (ou non renseigné),
               / CORR_STAT = "OUI" (ou non renseigné),
             # Si: equal_to("MULT_APPUI", 'OUI')
                 ◇ DIRECTION = float,
                 ◇ GROUP_NO = grno,
             # Si: equal_to("CORR_STAT", 'OUI')
                 ◆ D_FONC_DT = fonction / formule / nappe,
                 ◆ D_FONC_DT2 = fonction / formule / nappe,
          ),
        ◇ / MODE_STAT = mode_meca,
          / MODE_CORR = mode_meca / mult_elas,
        ◇ EXCIT_RESU = _F(
             ◆ RESULTAT = tran_gene,
             ◇ COEF_MULT = float (défaut: 1.0),
          ),
        ◇ COMPORTEMENT = _F(
             ◆ RELATION = / "ANTI_SISM",
                          / "CHOC_ELAS_TRAC",
                          / "DIS_CHOC",
                          / "DIS_ECRO_TRAC",
                          / "DIS_VISC",
                          / "FLAMBAGE",
                          / "RELA_EFFO_DEPL",
                          / "RELA_EFFO_VITE",
                          / "ROTOR_FISS",
             # Si: equal_to("RELATION", 'DIS_CHOC')
                 ◇ INTITULE = text,
                 ◆ / GROUP_MA = grma,
                   / GROUP_NO_1 = grno,
                 ◇ / GROUP_NO_2 = grno,
                 ◆ OBSTACLE = table_fonction,
                 ◇ ORIG_OBST = float,
                 ◆ NORM_OBST = float,
                 ◇ ANGL_VRIL = float,
                 ◇ JEU = float (défaut: 1.0),
                 ◇ DIST_1 = float,
                 ◇ DIST_2 = float,
                 ◇ SOUS_STRUC_1 = text,
                 ◇ SOUS_STRUC_2 = text,
                 ◇ REPERE = text (défaut: "GLOBAL"),
                 ◆ RIGI_NOR = float,
                 ◇ AMOR_NOR = float (défaut: 0.0),
                 ◇ RIGI_TAN = float (défaut: 0.0),
                 ◇ AMOR_TAN = float,
                 ◇ FROTTEMENT = / "COULOMB",
                                / "COULOMB_STAT_DYNA",
                                / "NON" (par défaut),
                 # Si: equal_to("FROTTEMENT", 'COULOMB')
                     ◆ COULOMB = float,
                     ◇ UNIDIRECTIONNEL = / "NON" (par défaut),
                                         / "OUI",
                 # Si: equal_to("FROTTEMENT", 'COULOMB_STAT_DYNA')
                     ◆ COULOMB_STAT = float,
                     ◆ COULOMB_DYNA = float,
                     ◇ UNIDIRECTIONNEL = / "NON" (par défaut),
                                         / "OUI",
             # Si: equal_to("RELATION", 'ROTOR_FISS')
                 ◇ ANGL_INIT = float (défaut: 0.0),
                 ◇ ANGL_ROTA = fonction / formule,
                 ◇ / GROUP_NO_G = grno,
                 ◆ / GROUP_NO_D = grno,
                 ◆ K_PHI = fonction / formule,
                 ◆ DK_DPHI = fonction / formule,
             # Si: equal_to("RELATION", 'FLAMBAGE')
                 ◇ INTITULE = text,
                 ◆ / GROUP_NO_1 = grno,
                 ◇ / GROUP_NO_2 = grno,
                 ◆ OBSTACLE = table_fonction,
                 ◇ ORIG_OBST = float,
                 ◆ NORM_OBST = float,
                 ◇ ANGL_VRIL = float,
                 ◇ JEU = float (défaut: 1.0),
                 ◇ DIST_1 = float,
                 ◇ DIST_2 = float,
                 ◇ REPERE = text (défaut: "GLOBAL"),
                 ◆ FX = fonction,
                 ◆ RIGI_NOR = fonction,
                 ◆ AMOR_NOR = fonction,
                 ◇ CRIT_AMOR = / "EXCLUS",
                               / "INCLUS" (par défaut),
             # Si: equal_to("RELATION", 'ANTI_SISM')
                 ◆ / GROUP_NO_1 = grno,
                 ◆ / GROUP_NO_2 = grno,
                 ◇ RIGI_K1 = float (défaut: 0.0),
                 ◇ RIGI_K2 = float (défaut: 0.0),
                 ◇ SEUIL_FX = float (défaut: 0.0),
                 ◇ C = float (défaut: 0.0),
                 ◇ PUIS_ALPHA = float (défaut: 0.0),
                 ◇ DX_MAX = float (défaut: 1.0),
             # Si: equal_to("RELATION", 'DIS_VISC')
                 ◆ / GROUP_NO_1 = grno,
                 ◆ / GROUP_NO_2 = grno,
                 ◆ / K1 = float,
                   / UNSUR_K1 = float,
                 ◆ / K2 = float,
                   / UNSUR_K2 = float,
                 ◆ / K3 = float,
                   / UNSUR_K3 = float,
                 ◆ C = float,
                 ◇ PUIS_ALPHA = float (défaut: 0.5),
                 ◇ ITER_INTE_MAXI = int (défaut: 20),
                 ◇ RESI_INTE = float (défaut: 1e-06),
             # Si: equal_to("RELATION", 'DIS_ECRO_TRAC')
                 ◆ / GROUP_NO_1 = grno,
                 ◆ / GROUP_NO_2 = grno,
                 ◆ / FX = fonction,
                   / FTAN = fonction,
                 # Si: exists("FTAN")
                     ◆ ECROUISSAGE = / "CINEMATIQUE",
                                     / "ISOTROPE",
                 ◇ ITER_INTE_MAXI = int (défaut: 20),
                 ◇ RESI_INTE = float (défaut: 1e-06),
             # Si: equal_to("RELATION", 'CHOC_ELAS_TRAC')
                 ◆ / GROUP_NO_1 = grno,
                 ◆ / GROUP_NO_2 = grno,
                 ◇ DIST_1 = float,
                 ◇ DIST_2 = float,
                 ◆ FX = fonction,
             # Si: equal_to("RELATION", 'RELA_EFFO_DEPL')
                 ◆ / GROUP_NO = grno,
                 ◇ SOUS_STRUC = text,
                 ◇ NOM_CMP = text,
                 ◆ FONCTION = fonction / formule / nappe,
             # Si: equal_to("RELATION", 'RELA_EFFO_VITE')
                 ◆ / GROUP_NO = grno,
                 ◇ SOUS_STRUC = text,
                 ◇ NOM_CMP = text,
                 ◆ FONCTION = fonction / formule / nappe,
          ),
        ◇ & BASE_ELAS_FLUI = melasflu,
          & NUME_VITE_FLUI = int,
        ◇ VERI_CHOC = _F(
             ◇ STOP_CRITERE = / "NON",
                              / "OUI" (par défaut),
             ◇ SEUIL = float (défaut: 0.5),
          ),
        # Si: exists("BASE_ELAS_FLUI")
            ◇ TRAITEMENT_NONL = "IMPLICITE",
        # Si: not exists("BASE_ELAS_FLUI")
            ◇ TRAITEMENT_NONL = / "EXPLICITE" (par défaut),
                                / "IMPLICITE",
    # Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'HARM')
        ⟐ SOLVEUR = _F(
             ◇ METHODE = / "LDLT" (par défaut),
                         / "MUMPS",
             # Si: equal_to("METHODE", 'MULT_FRONT')
                 ◇ RENUM = / "MD",
                           / "MDA" (par défaut),
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'LDLT')
                 ◇ RENUM = "RCMK",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'MUMPS')
                 ◇ RENUM = / "AMD",
                           / "AMF",
                           / "AUTO" (par défaut),
                           / "METIS",
                           / "PARMETIS",
                           / "PORD",
                           / "PTSCOTCH",
                           / "QAMD",
                           / "SCOTCH",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "LAGR2" (par défaut),
                               / "NON",
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
                 ◇ TYPE_RESOL = / "AUTO" (par défaut),
                                / "NONSYM",
                                / "SYMDEF",
                                / "SYMGEN",
                 ◇ ACCELERATION = / "AUTO",
                                  / "FR" (par défaut),
                                  / "FR+",
                                  / "FR++",
                                  / "LR",
                                  / "LR+",
                                  / "LR++",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 ◇ PRETRAITEMENTS = / "AUTO" (par défaut),
                                    / "SANS",
                 ◇ POSTTRAITEMENTS = / "AUTO" (par défaut),
                                     / "FORCE",
                                     / "MINI",
                                     / "SANS",
                 ◇ PCENT_PIVOT = int (défaut: 35),
                 ◇ NB_RHS = int (défaut: 1),
                 ◇ RESI_RELA = float (défaut: -1.0),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "EVAL",
                                     / "IN_CORE",
                                     / "OUT_OF_CORE",
             # Si: equal_to("METHODE", 'GCPC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ PRE_COND = / "LDLT_DP",
                              / "LDLT_INC" (par défaut),
                              / "LDLT_SP",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             # Si: equal_to("METHODE", 'PETSC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ ALGORITHME = / "CG",
                                / "CR",
                                / "FGMRES" (par défaut),
                                / "GCR",
                                / "GMRES",
                                / "GMRES_LMP",
                 ◇ OPTION_PETSC = text (défaut: ""),
                 ◇ PRE_COND = / "BLOC_LAGR",
                              / "BOOMER",
                              / "FIELDSPLIT",
                              / "GAMG",
                              / "HPDDM",
                              / "JACOBI",
                              / "LDLT_DP",
                              / "LDLT_INC",
                              / "LDLT_SP" (par défaut),
                              / "ML",
                              / "SANS",
                              / "SOR",
                              / "UTILISATEUR",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                     ◇ REMPLISSAGE = float (défaut: 1.0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 # Si: equal_to("PRE_COND", 'ML')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BOOMER')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'GAMG')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'HPDDM')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BLOC_LAGR')
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('FIELDSPLIT'))
                     ◇ RENUM = "SANS",
                     ◇ PARTITION_CMP = int,
                     ◇ NOM_CMP = text,
                 # Si: is_in("PRE_COND", ('UTILISATEUR'))
                     ◇ KSP_UTIL = not_checked,
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('JACOBI','SOR','SANS'))
                     ◇ RENUM = / "RCMK",
                               / "SANS" (par défaut),
          ),
    # Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'HARM')
        ⟐ SOLVEUR = _F(
             ◇ METHODE = / "LDLT",
                         / "MULT_FRONT",
                         / "MUMPS" (par défaut),
             # Si: equal_to("METHODE", 'MULT_FRONT')
                 ◇ RENUM = / "MD",
                           / "MDA" (par défaut),
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'LDLT')
                 ◇ RENUM = "RCMK",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'MUMPS')
                 ◇ RENUM = / "AMD",
                           / "AMF",
                           / "AUTO" (par défaut),
                           / "METIS",
                           / "PARMETIS",
                           / "PORD",
                           / "PTSCOTCH",
                           / "QAMD",
                           / "SCOTCH",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "LAGR2" (par défaut),
                               / "NON",
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
                 ◇ TYPE_RESOL = / "AUTO" (par défaut),
                                / "NONSYM",
                                / "SYMDEF",
                                / "SYMGEN",
                 ◇ ACCELERATION = / "AUTO",
                                  / "FR" (par défaut),
                                  / "FR+",
                                  / "FR++",
                                  / "LR",
                                  / "LR+",
                                  / "LR++",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 ◇ PRETRAITEMENTS = / "AUTO" (par défaut),
                                    / "SANS",
                 ◇ POSTTRAITEMENTS = / "AUTO" (par défaut),
                                     / "FORCE",
                                     / "MINI",
                                     / "SANS",
                 ◇ PCENT_PIVOT = int (défaut: 35),
                 ◇ NB_RHS = int (défaut: 1),
                 ◇ RESI_RELA = float (défaut: -1.0),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "EVAL",
                                     / "IN_CORE",
                                     / "OUT_OF_CORE",
             # Si: equal_to("METHODE", 'GCPC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ PRE_COND = / "LDLT_DP",
                              / "LDLT_INC" (par défaut),
                              / "LDLT_SP",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             # Si: equal_to("METHODE", 'PETSC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ ALGORITHME = / "CG",
                                / "CR",
                                / "FGMRES" (par défaut),
                                / "GCR",
                                / "GMRES",
                                / "GMRES_LMP",
                 ◇ OPTION_PETSC = text (défaut: ""),
                 ◇ PRE_COND = / "BLOC_LAGR",
                              / "BOOMER",
                              / "FIELDSPLIT",
                              / "GAMG",
                              / "HPDDM",
                              / "JACOBI",
                              / "LDLT_DP",
                              / "LDLT_INC",
                              / "LDLT_SP" (par défaut),
                              / "ML",
                              / "SANS",
                              / "SOR",
                              / "UTILISATEUR",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                     ◇ REMPLISSAGE = float (défaut: 1.0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 # Si: equal_to("PRE_COND", 'ML')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BOOMER')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'GAMG')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'HPDDM')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BLOC_LAGR')
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('FIELDSPLIT'))
                     ◇ RENUM = "SANS",
                     ◇ PARTITION_CMP = int,
                     ◇ NOM_CMP = text,
                 # Si: is_in("PRE_COND", ('UTILISATEUR'))
                     ◇ KSP_UTIL = not_checked,
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('JACOBI','SOR','SANS'))
                     ◇ RENUM = / "RCMK",
                               / "SANS" (par défaut),
          ),
    # Si: equal_to("BASE_CALCUL", 'PHYS') and equal_to("TYPE_CALCUL", 'TRAN')
        ⟐ SOLVEUR = _F(
             ◇ METHODE = / "GCPC",
                         / "LDLT",
                         / "MULT_FRONT",
                         / "MUMPS" (par défaut),
                         / "PETSC",
             # Si: equal_to("METHODE", 'MULT_FRONT')
                 ◇ RENUM = / "MD",
                           / "MDA" (par défaut),
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'LDLT')
                 ◇ RENUM = "RCMK",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'MUMPS')
                 ◇ RENUM = / "AMD",
                           / "AMF",
                           / "AUTO" (par défaut),
                           / "METIS",
                           / "PARMETIS",
                           / "PORD",
                           / "PTSCOTCH",
                           / "QAMD",
                           / "SCOTCH",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "LAGR2" (par défaut),
                               / "NON",
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
                 ◇ TYPE_RESOL = / "AUTO" (par défaut),
                                / "NONSYM",
                                / "SYMDEF",
                                / "SYMGEN",
                 ◇ ACCELERATION = / "AUTO" (par défaut),
                                  / "FR",
                                  / "FR+",
                                  / "FR++",
                                  / "LR",
                                  / "LR+",
                                  / "LR++",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 ◇ PRETRAITEMENTS = / "AUTO" (par défaut),
                                    / "SANS",
                 ◇ POSTTRAITEMENTS = / "AUTO" (par défaut),
                                     / "FORCE",
                                     / "MINI",
                                     / "SANS",
                 ◇ PCENT_PIVOT = int (défaut: 35),
                 ◇ REDUCTION_MPI = int (défaut: 0),
                 ◇ NB_RHS = int (défaut: 1),
                 ◇ RESI_RELA = float (défaut: -1.0),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "EVAL",
                                     / "IN_CORE",
                                     / "OUT_OF_CORE",
                 ◇ FILTRAGE_MATRICE = float (défaut: -1.0),
                 ◇ MIXER_PRECISION = / "NON" (par défaut),
                                     / "OUI",
             # Si: equal_to("METHODE", 'GCPC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ PRE_COND = / "LDLT_DP",
                              / "LDLT_INC" (par défaut),
                              / "LDLT_SP",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             # Si: equal_to("METHODE", 'PETSC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ ALGORITHME = / "CG",
                                / "CR",
                                / "FGMRES" (par défaut),
                                / "GCR",
                                / "GMRES",
                                / "GMRES_LMP",
                 ◇ OPTION_PETSC = text (défaut: ""),
                 ◇ PRE_COND = / "BLOC_LAGR",
                              / "BOOMER",
                              / "FIELDSPLIT",
                              / "GAMG",
                              / "HPDDM",
                              / "JACOBI",
                              / "LDLT_DP",
                              / "LDLT_INC",
                              / "LDLT_SP" (par défaut),
                              / "ML",
                              / "SANS",
                              / "SOR",
                              / "UTILISATEUR",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                     ◇ REMPLISSAGE = float (défaut: 1.0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 # Si: equal_to("PRE_COND", 'ML')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BOOMER')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'GAMG')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'HPDDM')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BLOC_LAGR')
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('FIELDSPLIT'))
                     ◇ RENUM = "SANS",
                     ◇ PARTITION_CMP = int,
                     ◇ NOM_CMP = text,
                 # Si: is_in("PRE_COND", ('UTILISATEUR'))
                     ◇ KSP_UTIL = not_checked,
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('JACOBI','SOR','SANS'))
                     ◇ RENUM = / "RCMK",
                               / "SANS" (par défaut),
          ),
    # Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'TRAN')
        ⟐ SOLVEUR = _F(
             ◇ METHODE = / "LDLT" (par défaut),
                         / "MULT_FRONT",
                         / "MUMPS",
             # Si: equal_to("METHODE", 'MULT_FRONT')
                 ◇ RENUM = / "MD",
                           / "MDA" (par défaut),
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'LDLT')
                 ◇ RENUM = "RCMK",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
             # Si: equal_to("METHODE", 'MUMPS')
                 ◇ RENUM = / "AMD",
                           / "AMF",
                           / "AUTO" (par défaut),
                           / "METIS",
                           / "PARMETIS",
                           / "PORD",
                           / "PTSCOTCH",
                           / "QAMD",
                           / "SCOTCH",
                 ◇ NPREC = int (défaut: 8),
                 ◇ ELIM_LAGR = / "LAGR2" (par défaut),
                               / "NON",
                               / "OUI",
                 ◇ STOP_SINGULIER = / "NON",
                                    / "OUI" (par défaut),
                 ◇ TYPE_RESOL = / "AUTO" (par défaut),
                                / "NONSYM",
                                / "SYMDEF",
                                / "SYMGEN",
                 ◇ ACCELERATION = / "AUTO",
                                  / "FR" (par défaut),
                                  / "FR+",
                                  / "FR++",
                                  / "LR",
                                  / "LR+",
                                  / "LR++",
                 ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 ◇ PRETRAITEMENTS = / "AUTO" (par défaut),
                                    / "SANS",
                 ◇ POSTTRAITEMENTS = / "AUTO" (par défaut),
                                     / "FORCE",
                                     / "MINI",
                                     / "SANS",
                 ◇ PCENT_PIVOT = int (défaut: 35),
                 ◇ NB_RHS = int (défaut: 1),
                 ◇ RESI_RELA = float (défaut: -1.0),
                 ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                     / "EVAL",
                                     / "IN_CORE",
                                     / "OUT_OF_CORE",
             # Si: equal_to("METHODE", 'GCPC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ PRE_COND = / "LDLT_DP",
                              / "LDLT_INC" (par défaut),
                              / "LDLT_SP",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
             # Si: equal_to("METHODE", 'PETSC')
                 ◇ ELIM_LAGR = / "NON" (par défaut),
                               / "OUI",
                 ◇ ALGORITHME = / "CG",
                                / "CR",
                                / "FGMRES" (par défaut),
                                / "GCR",
                                / "GMRES",
                                / "GMRES_LMP",
                 ◇ OPTION_PETSC = text (défaut: ""),
                 ◇ PRE_COND = / "BLOC_LAGR",
                              / "BOOMER",
                              / "FIELDSPLIT",
                              / "GAMG",
                              / "HPDDM",
                              / "JACOBI",
                              / "LDLT_DP",
                              / "LDLT_INC",
                              / "LDLT_SP" (par défaut),
                              / "ML",
                              / "SANS",
                              / "SOR",
                              / "UTILISATEUR",
                 ◇ RESI_RELA = float (défaut: 1e-06),
                 ◇ NMAX_ITER = int (défaut: 0),
                 # Si: equal_to("PRE_COND", 'LDLT_INC')
                     ◇ RENUM = "RCMK",
                     ◇ NIVE_REMPLISSAGE = int (défaut: 0),
                     ◇ REMPLISSAGE = float (défaut: 1.0),
                 # Si: is_in("PRE_COND", ('LDLT_SP', 'LDLT_DP'))
                     ◇ RENUM = / "METIS",
                               / "PARMETIS" (par défaut),
                               / "SANS",
                     ◇ REAC_PRECOND = int (défaut: 30),
                     ◇ PCENT_PIVOT = int (défaut: 20),
                     ◇ GESTION_MEMOIRE = / "AUTO" (par défaut),
                                         / "IN_CORE",
                     ◇ LOW_RANK_SEUIL = float (défaut: 0.0),
                 # Si: equal_to("PRE_COND", 'ML')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BOOMER')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'GAMG')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'HPDDM')
                     ◇ RENUM = "SANS",
                 # Si: equal_to("PRE_COND", 'BLOC_LAGR')
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('FIELDSPLIT'))
                     ◇ RENUM = "SANS",
                     ◇ PARTITION_CMP = int,
                     ◇ NOM_CMP = text,
                 # Si: is_in("PRE_COND", ('UTILISATEUR'))
                     ◇ KSP_UTIL = not_checked,
                     ◇ RENUM = "SANS",
                 # Si: is_in("PRE_COND", ('JACOBI','SOR','SANS'))
                     ◇ RENUM = / "RCMK",
                               / "SANS" (par défaut),
          ),
    ◇ TITRE = text,
    ◇ INFO = / 1,
             / 2,
    # Si: equal_to("BASE_CALCUL", 'GENE') and equal_to("TYPE_CALCUL", 'TRAN')
        ◇ IMPRESSION = _F(
             ◇ / TOUT = "OUI" (ou non renseigné),
               / | UNITE_DIS_VISC = unit,
                 | INST_FIN = float,
                 | INST_INIT = float,
                 | NIVEAU = / "DEPL_LOC",
                            / "FORC_LOC",
                            / "TAUX_CHOC",
                            / "VITE_LOC",
             ◇ / UNITE_DIS_ECRO_TRAC = unit,
          ),
)

◆ : obligatoire
◇ : optionnel
⟐ : présent par défaut
& : ensemble
/ : un seul parmi
| : plusieurs choix possibles