Syntaxe
=======

.. code-block:: text

    / datastructure
    / mode_acou
    / mode_flamb
    / mode_gene
    / mode_meca
    / mode_meca_c = CALC_MODES(
        ◇ TYPE_RESU = / "DYNAMIQUE" (par défaut),
                      / "GENERAL",
                      / "MODE_FLAMB",
        ◇ CHAM_MATER = cham_mater,
        ◇ CARA_ELEM = cara_elem,
        # Si: equal_to("TYPE_RESU", 'DYNAMIQUE')
            ◆ MATR_RIGI = matr_asse_depl_c / matr_asse_depl_r / matr_asse_elim_r / matr_asse_gene_c / matr_asse_gene_r / matr_asse_pres_r / matr_asse_temp_r,
            ◆ MATR_MASS = matr_asse_depl_r / matr_asse_elim_r / matr_asse_gene_r / matr_asse_pres_r / matr_asse_temp_r,
            ◇ MATR_AMOR = matr_asse_depl_r / matr_asse_gene_r,
            ◇ NORM_MODE = _F(
                 ◇ NORME = / "EUCL",
                           / "EUCL_TRAN",
                           / "MASS_GENE",
                           / "RIGI_GENE",
                           / "TRAN",
                           / "TRAN_ROTA" (par défaut),
                 ◇ INFO = / 1 (par défaut),
                          / 2,
              ),
            ◇ OPTION = / "AJUSTE",
                       / "BANDE",
                       / "CENTRE",
                       / "PLUS_GRANDE",
                       / "PLUS_PETITE" (par défaut),
                       / "PROCHE",
                       / "SEPARE",
                       / "TOUT",
            # Si: equal_to("OPTION", 'TOUT')
                ⟐ CALC_FREQ = _F(
                     ◇ NMAX_FREQ = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'PLUS_PETITE')
                ⟐ CALC_FREQ = _F(
                     ◇ NMAX_FREQ = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'PLUS_GRANDE')
                ⟐ CALC_FREQ = _F(
                     ◇ NMAX_FREQ = int (défaut: 1),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'CENTRE')
                ⟐ CALC_FREQ = _F(
                     ◆ FREQ = float,
                     ◇ AMOR_REDUIT = float,
                     ◇ NMAX_FREQ = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'BANDE')
                ⟐ CALC_FREQ = _F(
                     ◆ FREQ = float,
                     ◇ TABLE_FREQ = table,
                     # Si: size('FREQ') > 2
                         ◇ NIVEAU_PARALLELISME = / "COMPLET" (par défaut),
                                                 / "PARTIEL",
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'PROCHE')
                ⟐ CALC_FREQ = _F(
                     ◆ FREQ = float,
                     ◇ AMOR_REDUIT = float,
                     ◇ NMAX_FREQ = int (défaut: 0),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE'))
                ⟐ CALC_FREQ = _F(
                     ◆ FREQ = float,
                     ◇ AMOR_REDUIT = float,
                     ◇ NMAX_FREQ = int (défaut: 0),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_FREQ = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('PLUS_PETITE','PLUS_GRANDE','BANDE','CENTRE','TOUT'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ METHODE = / "JACOBI",
                                 / "QZ",
                                 / "SORENSEN" (par défaut),
                                 / "TRI_DIAG",
                     # Si: equal_to("METHODE", 'TRI_DIAG')
                         ◇ PREC_ORTHO = float (défaut: 1e-12),
                         ◇ NMAX_ITER_ORTHO = int (défaut: 5),
                         ◇ PREC_LANCZOS = float (défaut: 1e-08),
                         ◇ NMAX_ITER_QR = int (défaut: 30),
                         ◇ MODE_RIGIDE = / "NON" (par défaut),
                                         / "OUI",
                     # Si: equal_to("METHODE", 'JACOBI')
                         ◇ PREC_BATHE = float (défaut: 1e-10),
                         ◇ NMAX_ITER_BATHE = int (défaut: 40),
                         ◇ PREC_JACOBI = float (défaut: 0.01),
                         ◇ NMAX_ITER_JACOBI = int (défaut: 12),
                     # Si: equal_to("METHODE", 'SORENSEN')
                         ◇ PREC_SOREN = float (défaut: 0.0),
                         ◇ NMAX_ITER_SOREN = int (défaut: 20),
                         ◇ PARA_ORTHO_SOREN = float (défaut: 0.717),
                     # Si: equal_to("METHODE", 'QZ')
                         ◇ TYPE_QZ = / "QZ_EQUI",
                                     / "QZ_QR",
                                     / "QZ_SIMPLE" (par défaut),
                     ◇ APPROCHE = / "COMPLEXE",
                                  / "IMAG",
                                  / "REEL" (par défaut),
                     ◇ / DIM_SOUS_ESPACE = int,
                       / COEF_DIM_ESPACE = int,
                  ),
            # Si: is_in("OPTION",  ('SEPARE','AJUSTE','PROCHE'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ NMAX_ITER_SEPARE = int (défaut: 30),
                     ◇ PREC_SEPARE = float (défaut: 0.0001),
                     ◇ NMAX_ITER_AJUSTE = int (défaut: 15),
                     ◇ PREC_AJUSTE = float (défaut: 0.0001),
                     ◇ OPTION_INV = / "DIRECT" (par défaut),
                                    / "RAYLEIGH",
                     ◇ PREC_INV = float (défaut: 1e-05),
                     ◇ NMAX_ITER_INV = int (défaut: 30),
                  ),
            # Si: equal_to("OPTION", 'PROCHE')
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('SEPARE','AJUSTE')) and not exists("MATR_AMOR")
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('SEPARE','AJUSTE')) and exists("MATR_AMOR")
                ⟐ SOLVEUR = _F(
                     ◇ METHODE = / "LDLT",
                                 / "MULT_FRONT" (par défaut),
                     # Si: equal_to("METHODE", 'MULT_FRONT')
                         ◇ RENUM = / "MD",
                                   / "MDA" (par défaut),
                         ◇ NPREC = int (défaut: 8),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('PLUS_PETITE','PLUS_GRANDE','BANDE','CENTRE','TOUT'))
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_type("MATR_RIGI")==matr_asse_depl_r
                ◇ FILTRE_MODE = _F(
                     ◇ CRIT_EXTR = / "INER_EFFE_UN",
                                   / "MASS_EFFE_UN" (par défaut),
                                   / "MASS_GENE",
                     ◇ SEUIL = float (défaut: 0.001),
                  ),
                ◇ IMPRESSION = _F(
                     ◇ TOUT_PARA = / "NON",
                                   / "OUI" (par défaut),
                     ◇ CUMUL = / "NON",
                               / "OUI" (par défaut),
                     ◇ CRIT_EXTR = / "INER_EFFE_UN",
                                   / "MASS_EFFE_UN" (par défaut),
                                   / "MASS_GENE",
                  ),
            # Si: is_in("OPTION", ('PLUS_PETITE','PLUS_GRANDE','CENTRE','TOUT'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 1e-06),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON",
                               / "OUI" (par défaut),
                  ),
            # Si: equal_to("OPTION", 'BANDE')
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 1e-06),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "GLOBAL" (par défaut),
                               / "LOCAL",
                               / "NON",
                               / "OUI",
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 0.01),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON" (par défaut),
                               / "OUI",
                  ),
        # Si: equal_to("TYPE_RESU", 'MODE_FLAMB')
            ◆ MATR_RIGI = matr_asse_depl_r / matr_asse_gene_r / matr_asse_pres_r,
            ◆ MATR_RIGI_GEOM = matr_asse_depl_r / matr_asse_gene_r / matr_asse_pres_r,
            ◇ NORM_MODE = _F(
                 ◇ NORME = / "EUCL",
                           / "EUCL_TRAN",
                           / "MASS_GENE",
                           / "RIGI_GENE",
                           / "TRAN",
                           / "TRAN_ROTA" (par défaut),
                 ◇ INFO = / 1 (par défaut),
                          / 2,
              ),
            ◇ OPTION = / "AJUSTE",
                       / "BANDE",
                       / "CENTRE",
                       / "PLUS_PETITE" (par défaut),
                       / "PROCHE",
                       / "SEPARE",
                       / "TOUT",
            # Si: equal_to("OPTION", 'TOUT')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'PLUS_PETITE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'CENTRE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'BANDE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ TABLE_CHAR_CRIT = table,
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ NMAX_CHAR_CRIT = int (défaut: 0),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('PLUS_PETITE','BANDE','CENTRE','TOUT'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ METHODE = / "JACOBI",
                                 / "QZ",
                                 / "SORENSEN" (par défaut),
                                 / "TRI_DIAG",
                     # Si: equal_to("METHODE", 'TRI_DIAG')
                         ◇ PREC_ORTHO = float (défaut: 1e-12),
                         ◇ NMAX_ITER_ORTHO = int (défaut: 5),
                         ◇ PREC_LANCZOS = float (défaut: 1e-08),
                         ◇ NMAX_ITER_QR = int (défaut: 30),
                         ◇ MODE_RIGIDE = / "NON" (par défaut),
                                         / "OUI",
                     # Si: equal_to("METHODE", 'JACOBI')
                         ◇ PREC_BATHE = float (défaut: 1e-10),
                         ◇ NMAX_ITER_BATHE = int (défaut: 40),
                         ◇ PREC_JACOBI = float (défaut: 0.01),
                         ◇ NMAX_ITER_JACOBI = int (défaut: 12),
                     # Si: equal_to("METHODE", 'SORENSEN')
                         ◇ PREC_SOREN = float (défaut: 0.0),
                         ◇ NMAX_ITER_SOREN = int (défaut: 20),
                         ◇ PARA_ORTHO_SOREN = float (défaut: 0.717),
                     # Si: equal_to("METHODE", 'QZ')
                         ◇ TYPE_QZ = / "QZ_EQUI",
                                     / "QZ_QR",
                                     / "QZ_SIMPLE" (par défaut),
                     ◇ APPROCHE = / "COMPLEXE",
                                  / "IMAG",
                                  / "REEL" (par défaut),
                     ◇ / DIM_SOUS_ESPACE = int,
                       / COEF_DIM_ESPACE = int,
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ NMAX_ITER_SEPARE = int (défaut: 30),
                     ◇ PREC_SEPARE = float (défaut: 0.0001),
                     ◇ NMAX_ITER_AJUSTE = int (défaut: 15),
                     ◇ PREC_AJUSTE = float (défaut: 0.0001),
                     ◇ OPTION_INV = / "DIRECT" (par défaut),
                                    / "RAYLEIGH",
                     ◇ PREC_INV = float (défaut: 1e-05),
                     ◇ NMAX_ITER_INV = int (défaut: 30),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE', 'PROCHE'))
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('PLUS_PETITE','BANDE','CENTRE', 'TOUT'))
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('PLUS_PETITE','CENTRE','TOUT', 'BANDE'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 1e-06),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON",
                               / "OUI" (par défaut),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 0.01),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON" (par défaut),
                               / "OUI",
                  ),
        # Si: equal_to("TYPE_RESU", 'GENERAL')
            ◆ MATR_A = matr_asse_depl_r / matr_asse_gene_r / matr_asse_pres_r,
            ◆ MATR_B = matr_asse_depl_r / matr_asse_gene_r / matr_asse_pres_r,
            ◇ NORM_MODE = _F(
                 ◇ NORME = / "EUCL",
                           / "EUCL_TRAN",
                           / "MASS_GENE",
                           / "RIGI_GENE",
                           / "TRAN",
                           / "TRAN_ROTA" (par défaut),
                 ◇ INFO = / 1 (par défaut),
                          / 2,
              ),
            ◇ OPTION = / "AJUSTE",
                       / "BANDE",
                       / "CENTRE",
                       / "PLUS_PETITE" (par défaut),
                       / "PROCHE",
                       / "SEPARE",
                       / "TOUT",
            # Si: equal_to("OPTION", 'TOUT')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'PLUS_PETITE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'CENTRE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ NMAX_CHAR_CRIT = int (défaut: 10),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: equal_to("OPTION", 'BANDE')
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ TABLE_CHAR_CRIT = table,
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ CALC_CHAR_CRIT = _F(
                     ◆ CHAR_CRIT = float,
                     ◇ NMAX_CHAR_CRIT = int (défaut: 0),
                     ◇ NMAX_ITER_SHIFT = int (défaut: 3),
                     ◇ PREC_SHIFT = float (défaut: 0.05),
                     ◇ SEUIL_CHAR_CRIT = float (défaut: 0.01),
                  ),
            # Si: is_in("OPTION", ('PLUS_PETITE','BANDE','CENTRE','TOUT'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ METHODE = / "JACOBI",
                                 / "QZ",
                                 / "SORENSEN" (par défaut),
                                 / "TRI_DIAG",
                     # Si: equal_to("METHODE", 'TRI_DIAG')
                         ◇ PREC_ORTHO = float (défaut: 1e-12),
                         ◇ NMAX_ITER_ORTHO = int (défaut: 5),
                         ◇ PREC_LANCZOS = float (défaut: 1e-08),
                         ◇ NMAX_ITER_QR = int (défaut: 30),
                         ◇ MODE_RIGIDE = / "NON" (par défaut),
                                         / "OUI",
                     # Si: equal_to("METHODE", 'JACOBI')
                         ◇ PREC_BATHE = float (défaut: 1e-10),
                         ◇ NMAX_ITER_BATHE = int (défaut: 40),
                         ◇ PREC_JACOBI = float (défaut: 0.01),
                         ◇ NMAX_ITER_JACOBI = int (défaut: 12),
                     # Si: equal_to("METHODE", 'SORENSEN')
                         ◇ PREC_SOREN = float (défaut: 0.0),
                         ◇ NMAX_ITER_SOREN = int (défaut: 20),
                         ◇ PARA_ORTHO_SOREN = float (défaut: 0.717),
                     # Si: equal_to("METHODE", 'QZ')
                         ◇ TYPE_QZ = / "QZ_EQUI",
                                     / "QZ_QR",
                                     / "QZ_SIMPLE" (par défaut),
                     ◇ APPROCHE = / "COMPLEXE",
                                  / "IMAG",
                                  / "REEL" (par défaut),
                     ◇ / DIM_SOUS_ESPACE = int,
                       / COEF_DIM_ESPACE = int,
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ SOLVEUR_MODAL = _F(
                     ◇ NMAX_ITER_SEPARE = int (défaut: 30),
                     ◇ PREC_SEPARE = float (défaut: 0.0001),
                     ◇ NMAX_ITER_AJUSTE = int (défaut: 15),
                     ◇ PREC_AJUSTE = float (défaut: 0.0001),
                     ◇ OPTION_INV = / "DIRECT" (par défaut),
                                    / "RAYLEIGH",
                     ◇ PREC_INV = float (défaut: 1e-05),
                     ◇ NMAX_ITER_INV = int (défaut: 30),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE', 'PROCHE'))
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('PLUS_PETITE','BANDE','CENTRE', 'TOUT'))
                ⟐ 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),
                     # Si: equal_to("METHODE", 'LDLT')
                         ◇ RENUM = "RCMK",
                         ◇ NPREC = int (défaut: 8),
                     # 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",
                         ◇ 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')
                         ◇ 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')
                         ◇ 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: is_in("OPTION", ('PLUS_PETITE','CENTRE','TOUT', 'BANDE'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 1e-06),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON",
                               / "OUI" (par défaut),
                  ),
            # Si: is_in("OPTION", ('SEPARE','AJUSTE','PROCHE'))
                ⟐ VERI_MODE = _F(
                     ◇ STOP_ERREUR = / "NON",
                                     / "OUI" (par défaut),
                     ◇ SEUIL = float (défaut: 0.01),
                     ◇ PREC_SHIFT = float (défaut: 0.005),
                     ◇ STURM = / "NON" (par défaut),
                               / "OUI",
                  ),
        ◇ STOP_BANDE_VIDE = / "NON",
                            / "OUI" (par défaut),
        ◇ AMELIORATION = / "NON" (par défaut),
                         / "OUI",
        ◇ INFO = / 1 (par défaut),
                 / 2,
        ◇ TITRE = text,
    )
    
    ◆ : obligatoire
    ◇ : optionnel
    ⟐ : présent par défaut
    & : ensemble
    / : un seul parmi
    | : plusieurs choix possibles