Syntaxe
=======

.. code-block:: text

    cara_elem = AFFE_CARA_ELEM(
        ◆ MODELE = modele,
        ◇ INFO = / 1 (par défaut),
                 / 2,
        ◇ VERIF = / "NON",
                  / "OUI",
        ◆ | POUTRE = _F(
               ◆ SECTION = / "CERCLE",
                           / "COUDE",
                           / "GENERALE",
                           / "RECTANGLE",
               # Si: equal_to("SECTION", 'GENERALE')
                   ◆ GROUP_MA = list[grma],
                   ◇ VARI_SECT = / "CONSTANT" (par défaut),
                                 / "HOMOTHETIQUE",
                   # Si: equal_to("VARI_SECT", 'CONSTANT')
                       ◇ / TABLE_CARA = table,
                         / CARA = / "A",
                                  / "AI",
                                  / "AY",
                                  / "AZ",
                                  / "EY",
                                  / "EZ",
                                  / "IY",
                                  / "IYR2",
                                  / "IZ",
                                  / "IZR2",
                                  / "JG",
                                  / "JX",
                                  / "RT",
                                  / "RY",
                                  / "RZ",
                       ◇ & NOM_SEC = text,
                       ◇ & VALE = list[float], de 4 à 15 valeurs attendues,
                   # Si: equal_to("VARI_SECT", 'HOMOTHETIQUE')
                       ◆ CARA = / "A1",
                                / "A2",
                                / "AY1",
                                / "AY2",
                                / "AZ1",
                                / "AZ2",
                                / "EY1",
                                / "EY2",
                                / "EZ1",
                                / "EZ2",
                                / "IY1",
                                / "IY2",
                                / "IYR21",
                                / "IYR22",
                                / "IZ1",
                                / "IZ2",
                                / "IZR21",
                                / "IZR22",
                                / "JG1",
                                / "JG2",
                                / "JX1",
                                / "JX2",
                                / "RT1",
                                / "RT2",
                                / "RY1",
                                / "RY2",
                                / "RZ1",
                                / "RZ2",
                       ◆ VALE = list[float], de 8 à 30 valeurs attendues,
               # Si: equal_to("SECTION", 'RECTANGLE')
                   ◆ GROUP_MA = list[grma],
                   ◇ VARI_SECT = / "AFFINE",
                                 / "CONSTANT" (par défaut),
                                 / "HOMOTHETIQUE",
                   # Si: equal_to("VARI_SECT", 'CONSTANT')
                       ◆ CARA = / "EP",
                                / "EPY",
                                / "EPZ",
                                / "H",
                                / "HY",
                                / "HZ",
                       ◆ VALE = list[float], de 1 à 4 valeurs attendues,
                   # Si: equal_to("VARI_SECT", 'HOMOTHETIQUE')
                       ◆ CARA = / "EP1",
                                / "EP2",
                                / "EPY1",
                                / "EPY2",
                                / "EPZ1",
                                / "EPZ2",
                                / "H1",
                                / "H2",
                                / "HY1",
                                / "HY2",
                                / "HZ1",
                                / "HZ2",
                       ◆ VALE = list[float], de 2 à 8 valeurs attendues,
                   # Si: equal_to("VARI_SECT", 'AFFINE')
                       ◆ CARA = / "EPY",
                                / "EPZ1",
                                / "EPZ2",
                                / "HY",
                                / "HZ1",
                                / "HZ2",
                       ◆ VALE = list[float], de 3 à 6 valeurs attendues,
               # Si: equal_to("SECTION", 'CERCLE')
                   ◇ VARI_SECT = / "CONSTANT" (par défaut),
                                 / "HOMOTHETIQUE",
                   # Si: equal_to("VARI_SECT", 'CONSTANT')
                       ◆ GROUP_MA = list[grma],
                       ◆ CARA = / "EP",
                                / "R",
                       ◆ VALE = list[float], de 1 à 2 valeurs attendues,
                   # Si: equal_to("VARI_SECT", 'HOMOTHETIQUE')
                       ◆ GROUP_MA = list[grma],
                       ◆ CARA = / "EP_DEBUT",
                                / "EP_FIN",
                                / "R_DEBUT",
                                / "R_FIN",
                       ◆ VALE = list[float], de 2 à 4 valeurs attendues,
                   ◇ MODI_METRIQUE = / "NON" (par défaut),
                                     / "OUI",
                   ◇ FCX = fonction / formule / nappe,
                   ◇ TUYAU_NSEC = int, dans [8, 32] (défaut: 16),
                   ◇ TUYAU_NCOU = int, dans [1, 10] (défaut: 3),
               # Si: equal_to("SECTION", 'COUDE')
                   ◆ GROUP_MA = list[grma],
                   ◇ / COEF_FLEX = float, dans [0.0, ∞[,
                     / COEF_FLEX_XY = float, dans [0.0, ∞[,
                   ◇ / COEF_FLEX_XZ = float, dans [0.0, ∞[,
                   ◇ / INDI_SIGM = float, dans [0.0, ∞[,
                     / INDI_SIGM_XY = float, dans [0.0, ∞[,
                   ◇ / INDI_SIGM_XZ = float, dans [0.0, ∞[,
            ),
          | BARRE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ SECTION = / "CERCLE",
                           / "GENERALE",
                           / "RECTANGLE",
               # Si: equal_to("SECTION", 'GENERALE')
                   ◆ / TABLE_CARA = table,
                   ◇ & NOM_SEC = text,
                     / AIRE = float,
                     / CARA = "A" (ou non renseigné),
                   ◇ & VALE = float,
               # Si: equal_to("SECTION", 'RECTANGLE')
                   ◆ CARA = / "EP",
                            / "EPY",
                            / "EPZ",
                            / "H",
                            / "HY",
                            / "HZ",
                   ◆ VALE = list[float], de 1 à 4 valeurs attendues,
               # Si: equal_to("SECTION", 'CERCLE')
                   ◆ CARA = / "EP",
                            / "R",
                   ◆ VALE = list[float], de 1 à 2 valeurs attendues,
               ◇ FCX = fonction / formule / nappe,
            ),
          | CABLE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ N_INIT = float,
               ◆ / AIRE = float,
                 / RAYON = float,
                 / DIAMETRE = float,
               ◇ FCX = fonction / formule / nappe,
            ),
          | COQUE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ / EPAIS = float,
                 / EPAIS_FO = fonction / formule / nappe,
               ◇ / ANGL_REP = list[float], 2 valeurs attendues,
                 / VECTEUR = list[float], 3 valeurs attendues,
               ◇ A_CIS = float (défaut: 0.8333333),
               ◇ COEF_RIGI_DRZ = float (défaut: 1e-05),
               ◇ COQUE_NCOU = int (défaut: 1),
               ◇ / EXCENTREMENT = float,
               ◇ & INER_ROTA = "OUI" (ou non renseigné),
                 / EXCENTREMENT_FO = fonction / formule / nappe,
               ◇ MODI_METRIQUE = / "NON" (par défaut),
                                 / "OUI",
            ),
          | DISCRET = _F(
               ◇ REPERE = / "GLOBAL" (par défaut),
                          / "LOCAL",
               ◇ AMOR_HYST = float,
               ◇ SYME = / "NON",
                        / "OUI" (par défaut),
               # Si: equal_to("SYME", 'OUI')
                   ◇ CARA = / "A_TR_D_L",
                            / "A_TR_D_N",
                            / "A_TR_L",
                            / "A_TR_N",
                            / "A_T_D_L",
                            / "A_T_D_N",
                            / "A_T_L",
                            / "A_T_N",
                            / "K_TR_D_L",
                            / "K_TR_D_N",
                            / "K_TR_L",
                            / "K_TR_N",
                            / "K_T_D_L",
                            / "K_T_D_N",
                            / "K_T_L",
                            / "K_T_N",
                            / "M_TR_D_L",
                            / "M_TR_D_N",
                            / "M_TR_L",
                            / "M_TR_N",
                            / "M_T_D_L",
                            / "M_T_D_N",
                            / "M_T_L",
                            / "M_T_N",
                   # Si: ((equal_to("CARA", 'K_T_D_N')or(equal_to("CARA", 'A_T_D_N'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 3 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_D_L')or(equal_to("CARA", 'A_T_D_L'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 3 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_D_N')or(equal_to("CARA", 'A_TR_D_N'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 6 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_D_L')or(equal_to("CARA", 'A_TR_D_L'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 6 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_N') or
                   #      (equal_to("CARA", 'A_T_N') or
                   #      (equal_to("CARA", 'M_T_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 6 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_L') or
                   #      (equal_to("CARA", 'A_T_L') or
                   #      (equal_to("CARA", 'M_T_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 21 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_N') or
                   #      (equal_to("CARA", 'A_TR_N') or
                   #      (equal_to("CARA", 'M_TR_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 21 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_L') or
                   #      (equal_to("CARA", 'A_TR_L') or
                   #      (equal_to("CARA", 'M_TR_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 78 valeurs attendues,
                   # Si: (equal_to("CARA", 'M_T_D_N'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = float,
                   # Si: (equal_to("CARA", 'M_T_D_L'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = float,
                   # Si: (equal_to("CARA", 'M_TR_D_N'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 10 valeurs attendues,
                   # Si: (equal_to("CARA", 'M_TR_D_L'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 4 valeurs attendues,
               # Si: equal_to("SYME", 'NON')
                   ◇ CARA = / "A_TR_L",
                            / "A_TR_N",
                            / "A_T_L",
                            / "A_T_N",
                            / "K_TR_L",
                            / "K_TR_N",
                            / "K_T_L",
                            / "K_T_N",
                            / "M_TR_L",
                            / "M_TR_N",
                            / "M_T_L",
                            / "M_T_N",
                   # Si: ((equal_to("CARA", 'K_T_N') or
                   #      (equal_to("CARA", 'A_T_N') or
                   #      (equal_to("CARA", 'M_T_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 9 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_L') or
                   #      (equal_to("CARA", 'A_T_L') or
                   #      (equal_to("CARA", 'M_T_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 36 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_N') or
                   #      (equal_to("CARA", 'A_TR_N') or
                   #      (equal_to("CARA", 'M_TR_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 36 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_L') or
                   #      (equal_to("CARA", 'A_TR_L') or
                   #      (equal_to("CARA", 'M_TR_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 144 valeurs attendues,
            ),
          | DISCRET_2D = _F(
               ◇ REPERE = / "GLOBAL" (par défaut),
                          / "LOCAL",
               ◇ AMOR_HYST = float,
               ◇ SYME = / "NON",
                        / "OUI" (par défaut),
               # Si: equal_to("SYME", 'OUI')
                   ◇ CARA = / "A_TR_D_L",
                            / "A_TR_D_N",
                            / "A_TR_L",
                            / "A_TR_N",
                            / "A_T_D_L",
                            / "A_T_D_N",
                            / "A_T_L",
                            / "A_T_N",
                            / "K_TR_D_L",
                            / "K_TR_D_N",
                            / "K_TR_L",
                            / "K_TR_N",
                            / "K_T_D_L",
                            / "K_T_D_N",
                            / "K_T_L",
                            / "K_T_N",
                            / "M_TR_D_L",
                            / "M_TR_D_N",
                            / "M_TR_L",
                            / "M_TR_N",
                            / "M_T_D_L",
                            / "M_T_D_N",
                            / "M_T_L",
                            / "M_T_N",
                   # Si: ((equal_to("CARA", 'K_T_D_N')or(equal_to("CARA", 'A_T_D_N'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 2 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_D_L')or(equal_to("CARA", 'A_T_D_L'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 2 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_D_N')or(equal_to("CARA", 'A_TR_D_N'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 3 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_D_L')or(equal_to("CARA", 'A_TR_D_L'))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 3 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_N') or
                   #      (equal_to("CARA", 'A_T_N') or
                   #      (equal_to("CARA", 'M_T_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 3 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_L') or
                   #      (equal_to("CARA", 'A_T_L') or
                   #      (equal_to("CARA", 'M_T_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 10 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_N') or
                   #      (equal_to("CARA", 'A_TR_N') or
                   #      (equal_to("CARA", 'M_TR_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 6 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_L') or
                   #      (equal_to("CARA", 'A_TR_L') or
                   #      (equal_to("CARA", 'M_TR_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 21 valeurs attendues,
                   # Si: (equal_to("CARA", 'M_T_D_N'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = float,
                   # Si: (equal_to("CARA", 'M_T_D_L'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = float,
                   # Si: (equal_to("CARA", 'M_TR_D_N'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 4 valeurs attendues,
                   # Si: (equal_to("CARA", 'M_TR_D_L'))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 2 valeurs attendues,
               # Si: equal_to("SYME", 'NON')
                   ◇ CARA = / "A_TR_L",
                            / "A_TR_N",
                            / "A_T_L",
                            / "A_T_N",
                            / "K_TR_L",
                            / "K_TR_N",
                            / "K_T_L",
                            / "K_T_N",
                            / "M_TR_L",
                            / "M_TR_N",
                            / "M_T_L",
                            / "M_T_N",
                   # Si: ((equal_to("CARA", 'K_T_N') or
                   #      (equal_to("CARA", 'A_T_N') or
                   #      (equal_to("CARA", 'M_T_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 4 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_T_L') or
                   #      (equal_to("CARA", 'A_T_L') or
                   #      (equal_to("CARA", 'M_T_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 16 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_N') or
                   #      (equal_to("CARA", 'A_TR_N') or
                   #      (equal_to("CARA", 'M_TR_N')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 9 valeurs attendues,
                   # Si: ((equal_to("CARA", 'K_TR_L') or
                   #      (equal_to("CARA", 'A_TR_L') or
                   #      (equal_to("CARA", 'M_TR_L')))))
                       ◆ GROUP_MA = list[grma],
                       ◆ VALE = list[float], 36 valeurs attendues,
            ),
          | GRILLE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ / SECTION = float,
                 / SECTION_FO = fonction / formule / nappe,
               ◆ / ANGL_REP_1 = list[float], 2 valeurs attendues,
                 / ANGL_REP_2 = list[float], 2 valeurs attendues,
                 / VECT_1 = list[float], 3 valeurs attendues,
                 / VECT_2 = list[float], 3 valeurs attendues,
               ◇ / EXCENTREMENT = float,
                 / EXCENTREMENT_FO = fonction / formule / nappe,
               ◇ REPERE = / "CYLINDRIQUE",
                          / "GLOBAL" (par défaut),
               # Si: (equal_to("REPERE", "CYLINDRIQUE"))
                   ◆ ORIGINE = list[float], 3 valeurs attendues,
                   ◆ AXE_Z = list[float], 3 valeurs attendues,
               ◇ COEF_RIGI_DRZ = float (défaut: 1e-10),
            ),
          | MASSIF = _F(
               ◆ / GROUP_MA = list[grma],
                 / TOUT = "OUI" (ou non renseigné),
               ◆ / CHAM_ORIE = carte / cham_no,
                 / ANGL_REP = list[float], de 1 à 3 valeurs attendues,
                 / ORIG_AXE = list[float], de 2 à 3 valeurs attendues,
                 / ANGL_EULER = list[float], de 1 à 3 valeurs attendues,
               ◇ & ANGL_AXE = list[float], 2 valeurs attendues,
            ),
          | MASS_REP = _F(
               ◆ GROUP_MA = grma,
               ◆ GROUP_MA_POI1 = grma,
               ◆ VALE = float,
               ◆ TYPE = / "LINEIQUE",
                        / "SURFACIQUE",
                        / "TOTALE",
               ◇ FONC_MULT = fonction / formule / nappe,
            ),
          | MEMBRANE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ EPAIS = float, dans [0.0, ∞[,
               ◇ / ANGL_REP_1 = list[float], 2 valeurs attendues,
                 / ANGL_REP_2 = list[float], 2 valeurs attendues,
                 / VECT_1 = list[float], 3 valeurs attendues,
                 / VECT_2 = list[float], 3 valeurs attendues,
               ◇ N_INIT = float, dans [0.0, ∞[ (défaut: 0.0),
            ),
          | MULTIFIBRE = _F(
               ◆ GROUP_MA = list[grma],
               ◆ GROUP_FIBRE = list[text],
               ◇ PREC_AIRE = float (défaut: 0.01),
               ◇ PREC_INERTIE = float (défaut: 0.1),
            ),
          | RIGI_PARASOL = _F(
               ◆ GROUP_MA = list[grma],
               ◆ / GROUP_MA_POI1 = grma,
                 / GROUP_MA_SEG2 = grma,
               ◆ / FONC_GROUP = list[fonction / formule / nappe],
                 / COEF_GROUP = list[float],
               ◇ REPERE = / "GLOBAL" (par défaut),
                          / "LOCAL",
               ◆ CARA = / "A_TR_D_L",
                        / "A_TR_D_N",
                        / "A_T_D_L",
                        / "A_T_D_N",
                        / "K_TR_D_L",
                        / "K_TR_D_N",
                        / "K_T_D_L",
                        / "K_T_D_N",
               # Si: exists("CARA") and (len(CARA)==1 or (len(CARA)==2 and CARA[0][2:]==CARA[1][2:]))
                   ◆ VALE = list[float],
               ◆ / GROUP_NO_CENTRE = grno,
                 / COOR_CENTRE = list[float], de 2 à 3 valeurs attendues,
               ◇ UNITE = unit,
            ),
          | RIGI_GRILLE = _F(
               ◆ GROUP_MA = grma,
               ◆ GROUP_MA_SEG2 = grma, 5 valeurs attendues,
               ◆ VALE = float, 5 valeurs attendues,
               ◆ GROUP_NO_CENTRE = grno, 5 valeurs attendues,
               ◇ OPTION = "RIGI" (par défaut),
            ),
          | MASS_REP = _F(
               ◆ GROUP_MA = grma,
               ◆ GROUP_MA_POI1 = grma,
               ◆ VALE = float,
               ◆ TYPE = / "LINEIQUE",
                        / "SURFACIQUE",
                        / "TOTALE",
               ◇ FONC_MULT = fonction / formule / nappe,
            ),
        ◇ ORIENTATION = _F(
             ◆ CARA = / "ANGL_NAUT",
                      / "ANGL_VRIL",
                      / "GENE_TUYAU",
                      / "VECT_MAIL_Y",
                      / "VECT_MAIL_Z",
                      / "VECT_X_Y",
                      / "VECT_Y",
                      / "VECT_Z",
             # Si: (equal_to("CARA", 'VECT_Y'))
                 ◆ GROUP_MA = list[grma],
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'VECT_Z'))
                 ◆ GROUP_MA = list[grma],
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'VECT_MAIL_Y'))
                 ◆ GROUP_MA = list[grma],
                 ◆ TABLE_CARA = table,
                 ◆ NOM_SEC = text,
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'VECT_MAIL_Z'))
                 ◆ GROUP_MA = list[grma],
                 ◆ TABLE_CARA = table,
                 ◆ NOM_SEC = text,
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'ANGL_VRIL'))
                 ◆ GROUP_MA = list[grma],
                 ◆ VALE = float,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'VECT_X_Y'))
                 ◆ GROUP_MA = list[grma],
                 ◆ VALE = list[float], 6 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'ANGL_NAUT'))
                 ◆ GROUP_MA = list[grma],
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float,
             # Si: (equal_to("CARA", 'GENE_TUYAU'))
                 ◆ GROUP_NO = grno,
                 ◆ VALE = list[float], 3 valeurs attendues,
                 ◇ PRECISION = float (défaut: 0.0001),
                 ◇ CRITERE = / "ABSOLU",
                             / "RELATIF" (par défaut),
          ),
        ◇ POUTRE_FLUI = _F(
             ◆ GROUP_MA = list[grma],
             ◆ B_T = float,
             ◆ B_N = float,
             ◇ B_TN = float (défaut: 0.0),
             ◆ A_FLUI = float,
             ◆ A_CELL = float,
             ◆ COEF_ECHELLE = float,
          ),
        ◇ RIGI_MISS_3D = _F(
             ◆ GROUP_MA_POI1 = grma,
             ◇ GROUP_MA_SEG2 = grma,
             ◆ FREQ_EXTR = float,
             ◇ UNITE_RESU_IMPE = unit (défaut: 30),
          ),
        ◇ MASS_AJOU = _F(
             ◆ GROUP_MA = grma,
             ◆ GROUP_MA_POI1 = grma,
             ◆ FONC_GROUP = fonction / formule / nappe,
          ),
        ◇ & GEOM_FIBRE = gfibre,
    )

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