2. Syntaxe#

/ 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