
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

// implantation de la classe ParaAlgoControle

#include <stdlib.h>
using namespace std;  //introduces namespace std
#include <math.h>

#include "ParaAlgoControle.h"
#include "MotCle.h"
#include "ParaGlob.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "CharUtil.h"

// ================ paramètres static ======================
// valeur par défaut de coef_pas_critique_deltat, compliqué pour qu'il n'y est pas de doute d'égalité
double ParaAlgoControle::coef_defaut_pa_critique = 0.853247689523; 
// pour le temps
VariablesTemps ParaAlgoControle::tempo; // init aux valeurs par défaut

//================= fin paramètres static ====================
    
   //  CONSTRUCTEUR
// par défaut
ParaAlgoControle::ParaAlgoControle() :
    tempo_specifique_algo(),
  // on initialise les listes par défaut
  type_matrice_secondaire(),type_resolution_secondaire(),type_preconditionnement_secondaire()
  ,nb_iter_nondirecte_secondaire(),tolerance_secondaire(),nb_vect_restart_secondaire()
  ,opti_pointeur_assemblage(0)

  {// on met les parametres a leurs valeurs par defaut
        // 1)  parametres de controle généraux pour la résolution de l'équilibre
        //     générale
    sauvegarde = 1; // frequence de sauvegarde
    cas_de_sauvegarde = 1; // cas de gestion de la fréquence de sauvegarde, par défaut sauvegarde
          // indique le nombre d'incréments entre deux sauvegardes
    tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi = 1.;  // increment de temps maxi
    tempo_specifique_algo.deltatmini = tempo.deltatmini = 0.;  // increment de temps mini
    coef_pas_critique_deltatmaxi = 0.; // // coeff  du pas critique pour deltatmaxi s'il existe
    coef_pas_critique_deltatmini = -3333256794.; // // coeff  du pas critique pour deltatmini s'il existe
    typeDFC_pas_critique_deltatmaxi = true; // par défaut pas critique DFC
    typeDFC_pas_critique_deltatmini = true; // par défaut pas critique DFC
    
    iterations = 100; // maxi d'iteration pour converger
    precision = 1.e-3; // precision de la convergence
    tempo_specifique_algo.prectemps = tempo.prectemps = 1.E-12; // precision sur le temps final
    norme.nom1 = "Residu/Reaction"; // type de norme de convergence
    norme.nom2 = " "; // ne sert que si norme.nom1 = fonction_nD:
    cinematique = false; // cinematique sur l'increment ?
    conv_forcee = false; // convergence forcee ?
    multiplicateur = 1.; // multiplicateur de la charge
    tempo_specifique_algo.deltat = tempo.deltat = 1.;  // increment de temps
    force_deltat = false; // a priori on reprend le deltat sauvegardé au pas précédent
    coef_pas_critique_deltat=coef_defaut_pa_critique; // coeff  du pas critique pour deltat s'il existe
    typeDFC_pas_critique_deltat = true; // par défaut pas critique DFC
    tempo_specifique_algo.tempsfin = tempo.tempsfin = 1.; // temps de fin de calcul
    maxincre = 400 ; // maximum d'increment de temps
    max_essai_incre = maxincre; // maximum de tentative d'increment de temps permis
    restart = 0;  // increment de redemarage de calcul
    max_puissance = 1.e10; // maximum de la puissance tolérée dans le calcul
    line_search = false; // line_seach désactivée par défaut
    var_charge_externe = true; // charge externe participe à la raideur
    var_jacobien = false; // variation du jacobien dans le calcul de la raideur
    var_D = false; // variation de la vitesse de déformation dans le calcul de la raideur
    // on renseigne la class ParaGlob sur les variables temps
    ParaGlob::Init_temps(tempo);
    
    
        // 2) paramètres liés au systèmes d'équations linéaire
        
    type_matrice = BANDE_SYMETRIQUE; // type de stockage matriciel
    symetrie_matrice = true; // assemblage symétrique par défaut
    type_resolution = CHOLESKY; // type de résolution
    type_preconditionnement = DIAGONAL; // type de préconditionnement 
    nb_iter_nondirecte = 30; // nombre d'itération dans le cas d'une méthode itérative
    tolerance = 1.e-7; // tolerance de convergence dans le cas d'une méthode itérative
    nb_vect_restart = 32; // nombre de vecteur sauvegardé dans le cas d'une méthode
                             // itérative avec redépart
    // pour les matrices secondaires éventuelles, aucune déclaration, car
    // par défaut il n'y en a pas
   
        // 3) paramètres liés au pilotage de l'équilibre global
    type_de_pilotage = PILOTAGE_BASIQUE; // type de pilotage basique par défaut    
    facteur_diminution = sqrt(3.);   // facteurs d'augmentation, ou de diminution
    facteur_augmentation = sqrt(2.); // du paramètre de chargement
    fact_dim_en_mauvaiseConv = 1.23; // facteurs de diminution après une mauvaise convergence
    nb_bonne_convergence = 3;    // nb de bonne convergence -> augmentation du deltatt                    
    nb_iter_pour_bonne_convergence = 0.25 * iterations; // nb d'iter pour statuer sur la bonne convergence 
    nb_iter_pour_mauvaise_convergence = 0.5 * iterations; // nb d'iter pour statuer sur la bonne convergence   
    init_comp_tangent_simple = -1; // nb d'itération avec un comportement tangent simple
    sur_sous_relaxation = 1.;  // facteur de sur ou sous relaxation
    norme_incre_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl
    // pour les deux lignes qui suivent, ne pas bouger le maxi (==ConstMath::tresgrand) car
    // il sert à savoir si les limitations sont actives c-a-d modifié par l'utilisateur
    norme_incre_X_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl de déplacement
    norme_incre_V_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl de vitesse
    //
    varMiniDdl = 0.; // limite mini en dessous de laquelle on considère qu'il n'y a pas convergence
    varMaxiDdl = ConstMath::tresgrand;  // idem en maxi
    nbCycleControleResidu = 3; // entre combien d'iter on compare le max résidu
    plageControleResidu = 3;  // combien de fois il faut que le test soit négatif pour la non convergence
    initIncreAvecDeltaDdlPrec = 1.; // initialisation de l'incrément avec l'incrément du pas précédent
    jabobien_negatif = 1; // traitement du cas des jacobiens négatifs
    var_maxi_jacobien = 0; // variation maxi autorisée du jacobien, si <= 1 pas pris en compte
    cas_fctnD_charge = 0; // traitement d'un retour de fct nD problématique: dans le chargement

        // 4) paramètres liès à la dynamique
    type_calcul_masse = MASSE_DIAG_COEF_EGAUX; // type de calcul de la masse
                     // le type de stockage de la masse utilisée est celui de type_matrice 
                     // qui est utilisé uniquement lorque la matrice masse n'est pas diagonale`
    limitation_temps_maxi_stable = true; // booléen qui indique si la limitation supérieur
             // du temps pour satisfaire la stabilité, est active ou pas   
    amort_visco_arti = 0; // indique si l'on inclut automatiquement un amortissement visqueux artificiel
    visco_arti = 0.01; // valeur de la viscosité dynamique
    maxi_C_en_fonction_M = 10000; // coef tel que: maxi C = maxi_C_en_fonction_M * M (cas de C critique)
    coef_rayleigh_masse = 1.;  // coeffs de rayleigh sur la masse pour la construction de [C]
    coef_rayleigh_raideur = 0.;  // coeffs de rayleigh sur la raideur  pour la construction de [C]
             // cas du bulk viscosity  
    bulk_viscosity = 0; // indique si oui ou non on utilise le bulk viscosity
    c_Tracebulk = 1.5; // coefficient de la trace de D
    c_Trace2bulk = 0.06; // coefficient du carré de la trace de D
           
        // 5) paramètres liès à l'affichage des résultats
    frequence_affichage_increment = 1; // fréquence sur les increments de l'affichage des résultats
    frequence_affichage_iteration = 1; // fréquence sur les itération de l'affichage des résultats
    sortie_fil_calcul = -1000000; // fréquence sur les incréments, pour la sortie au fil du calcul
    cas_de_sortie_fil_calcul = 1; // par défaut le paramètre sortie_fil_calcul = un delta incrément
    // nombre de chiffre significatifs utilisé pour l'affichage des double précision: le premier pour
    // l'archivage du calcul le secon pour la visualisation graphique
    nb_diggit_double_calcul = 17; 
    nb_diggit_double_graphique = 12;
    nb_diggit_double_ecran= 8;
        // 6)  paramètres liès au contact
    prec_pt_int_deb = 1.e-6; // précision du test: point intérieur ?, avant le début des calculs
	   factPourRayonAccostage = 1.; // facteur multiplicatif du déplacement maxi entre t et tdt, donnant
										   // distance maxi admissible entre le point et le point projeté
	   distanceMaxiAuPtProjete = ConstMath::grand; // a priori grand, est ensuite éventuellement géré par l'entrée des données									
    extra_boite_prelocalisation = 1.05; // donne la proportion de plus que l'on prend pour les boites
    mini_extra_boite_prelocalisation = 0.001; // permet le calcul de la bande mini autour de la boite
    ajout_extra_boite_prelocalisation = 0.; // ajout dans toutes les directions à la boite
    contact_type = 0; // a priori il n'y a pas de contact de prélocalisation d'élément
    fct_nD_bascul_contact_type_4="_"; // a priori pas de fonction nD

    penalisationPenetration = 0.1; // facteur pour le calcul du facteur de pénalisation pour la pénétration
    fct_nD_penalisationPenetration="_"; // pas de fonction par défaut
    
    typePenalisationPenetration = 2; // par défaut le calcul est celui de ls-dyna avec la compressibilité du maître
	   penetration_contact_maxi = 0.1; // par défaut on met 1/10 de penetration, 
    fct_nD_penetration_contact_maxi="_"; // pas de fonction par défaut

	   penetration_borne_regularisation = ConstMath::tresgrand; // par défaut n'intervient pas
    fct_nD_penetration_borne_regularisation="_"; // pas de fonction par défaut

	   force_contact_noeud_maxi = ConstMath::tresgrand; // borne maxi pour la force de réaction du noeud ,
    fct_nD_force_contact_noeud_maxi="_"; // pas de fonction par défaut

    penalisationTangentielle = 1.e6; // facteur de pénalisation pour le déplacement tangentiel
    fct_nD_penalisationTangentielle="_"; // pas de fonction par défaut

    typePenalisationTangentielle = 2; // indique le type de calcul pour la pénalisation pour le dep tangentiel
    tangentielle_contact_maxi = 0.1; // indique une borne maxi de dep tangentiel (dont l'utilisation dépend de l'algo)
    fct_nD_tangentielle_contact_maxi="_"; // pas de fonction par défaut

    tangentielle_borne_regularisation = ConstMath::tresgrand;// par défaut n'intervient pas
    fct_nD_tangentielle_borne_regularisation="_"; // pas de fonction par défaut

    force_tangentielle_noeud_maxi = ConstMath::tresgrand;; // indique une borne maxi pour la force tangentielle
    fct_nD_force_tangentielle_noeud_maxi="_"; // pas de fonction par défaut

    prec_pt_sur_frontiere = 1.e-4; // précision de positionnement sur les X^ar d'un pt en contact sur une frontière
    nb_boucle_newton_position_frontiere = 10; // nb de boucle maxi pour la recherche du positionnement du pt en contact 
    nbDecolAutorise = 1; // nb de fois un noeud décolle pour n'être plus considéré en contact 
	   typeDeDecolement = 0; // type par défaut sur la réaction
    nb_glissant = 1; // par défaut il n'y a pas de moyenne glissante
    
    niveau_commentaire_lescontacts = 0;  // par défaut c'est le général qui commande
    niveau_commentaire_contact = 0;  // par défaut c'est le général qui commande
    fct_niveau_commentaire_contact = "_";// pas de fonction par défaut
    
    optimisation_numerotation = 0; // par défaut pas d'optimisation
	   
        // 7) paramètres liés aux calculs des énergies 
    nb_incr_cal_ener=1; // donne l'incrément mini, à partir duquel on calcul les énergie cumulée
    affiche_incr_energie=false; // affichage oui ou non de l'énergie et du bilan sur l'incrément 
        // 8) paramètres liés aux calculs géométriques sur les éléments
    point_interne_delta_thetai_maxi = 1.e-4; // coordonnée thetai ok si delta thetai < à la prec
    point_interne_prec_thetai_interne = 1.e-6; // precision sur thetai sur le test du point interne
    point_interne_nb_boucle_sur_delta_thetai = 10; // maxi boucle de Newton sur la recherche des thetai
    point_interne_nb_externe = 3; //nb max de test positif "externe" pour statuer un point externe 
	   cal_vol_total_entre_surface_et_plans_ref = false; // par défaut il n'y a pas de calcul de ces volumes
    ratio_maxi_jacoMembrane_jacoPti = 200.; //rapport maxi autorisé entre le jacobien de la facette centrale
    // et le jacobien au pti pour les éléments coques
	   type_calnum_inversion_metrique = CRAMER; // méthode historique
          
        //------------ gestion de certaines interruptions systèmes ---------
    // ces variables ne sont pas sauvegardées, elles sont accessibles de partout pour un projet donné
    // on se sert de ParaAlgoControle pour le stockage, l'accès et la modification
    sortieEquilibreGlobal=false; // par défaut
    sortieEtatActuelDansBI=false; // par défaut
    sortieEtatActuelDansCVisu = false; // par défaut
   
   };

// de copie
ParaAlgoControle::ParaAlgoControle(const ParaAlgoControle& p) :
   sauvegarde(p.sauvegarde),cas_de_sauvegarde(p.cas_de_sauvegarde),
   tempo_specifique_algo(p.tempo_specifique_algo),
   force_deltat(p.force_deltat),
   coef_pas_critique_deltatmaxi(p.coef_pas_critique_deltatmaxi),
   coef_pas_critique_deltatmini(p.coef_pas_critique_deltatmini),
   typeDFC_pas_critique_deltatmaxi(p.typeDFC_pas_critique_deltatmaxi),
   typeDFC_pas_critique_deltatmini(p.typeDFC_pas_critique_deltatmini),
   iterations(p.iterations), precision(p.precision),
   norme(p.norme),//prectemps(p.prectemps),
   cinematique(p.cinematique),conv_forcee(p.conv_forcee),
   multiplicateur(p.multiplicateur),//deltat(p.deltat),
   coef_pas_critique_deltat(p.coef_pas_critique_deltat),
   typeDFC_pas_critique_deltat(p.typeDFC_pas_critique_deltat),
   maxincre(p.maxincre),//tempsfin(p.tempsfin),
   max_essai_incre(p.max_essai_incre),
   restart(p.restart),max_puissance(p.max_puissance),
   line_search(p.line_search),var_charge_externe(p.var_charge_externe),
   var_jacobien(p.var_jacobien),var_D(p.var_D),
   type_matrice(p.type_matrice),symetrie_matrice(p.symetrie_matrice),
   type_resolution(p.type_resolution),
   type_preconditionnement(p.type_preconditionnement),
   nb_iter_nondirecte(p.nb_iter_nondirecte),
   tolerance(p.tolerance),nb_vect_restart(p.nb_vect_restart),
   type_matrice_secondaire(p.type_matrice_secondaire),
   type_resolution_secondaire(p.type_resolution_secondaire),
   type_preconditionnement_secondaire(p.type_preconditionnement_secondaire),
   nb_iter_nondirecte_secondaire(p.nb_iter_nondirecte_secondaire),
   tolerance_secondaire(p.tolerance_secondaire),nb_vect_restart_secondaire(p.nb_vect_restart_secondaire),
   opti_pointeur_assemblage(p.opti_pointeur_assemblage),
   type_de_pilotage(p.type_de_pilotage),facteur_diminution(p.facteur_diminution),
   facteur_augmentation(p.facteur_augmentation),fact_dim_en_mauvaiseConv(p.fact_dim_en_mauvaiseConv),
   nb_bonne_convergence(p.nb_bonne_convergence),
   nb_iter_pour_bonne_convergence(p.nb_iter_pour_bonne_convergence),
   nb_iter_pour_mauvaise_convergence(p.nb_iter_pour_mauvaise_convergence),
   init_comp_tangent_simple(p.init_comp_tangent_simple),
   norme_incre_max(p.norme_incre_max),norme_incre_X_max(p.norme_incre_X_max),
   norme_incre_V_max(p.norme_incre_V_max),
   varMiniDdl(p.varMiniDdl),varMaxiDdl(p.varMaxiDdl),
   nbCycleControleResidu(p.nbCycleControleResidu),plageControleResidu(p.plageControleResidu),
   sur_sous_relaxation(p.sur_sous_relaxation),initIncreAvecDeltaDdlPrec(p.initIncreAvecDeltaDdlPrec),
   jabobien_negatif(p.jabobien_negatif),var_maxi_jacobien(p.var_maxi_jacobien),
   cas_fctnD_charge(p.cas_fctnD_charge),
   type_calcul_masse(p.type_calcul_masse),
   limitation_temps_maxi_stable(p.limitation_temps_maxi_stable),
   amort_visco_arti(p.amort_visco_arti),visco_arti(p.visco_arti),
   maxi_C_en_fonction_M(p.maxi_C_en_fonction_M),
   coef_rayleigh_masse(p.coef_rayleigh_masse),coef_rayleigh_raideur(p.coef_rayleigh_raideur),
   bulk_viscosity(p.bulk_viscosity),c_Tracebulk(p.c_Tracebulk),c_Trace2bulk(p.c_Trace2bulk),   
   frequence_affichage_increment(p.frequence_affichage_increment),
   frequence_affichage_iteration(p.frequence_affichage_iteration),
   sortie_fil_calcul(p.sortie_fil_calcul),
   cas_de_sortie_fil_calcul(p.cas_de_sortie_fil_calcul),
   nb_diggit_double_calcul(p.nb_diggit_double_calcul),
   nb_diggit_double_graphique(p.nb_diggit_double_graphique),
   nb_diggit_double_ecran(p.nb_diggit_double_ecran),
   nb_incr_cal_ener(p.nb_incr_cal_ener),
   affiche_incr_energie(p.affiche_incr_energie),
   prec_pt_int_deb(p.prec_pt_int_deb),factPourRayonAccostage(p.factPourRayonAccostage),
	  distanceMaxiAuPtProjete(p.distanceMaxiAuPtProjete),
	  extra_boite_prelocalisation(p.extra_boite_prelocalisation),
   mini_extra_boite_prelocalisation(p.mini_extra_boite_prelocalisation),
   ajout_extra_boite_prelocalisation(p.ajout_extra_boite_prelocalisation),
   contact_type(p.contact_type),prec_pt_sur_frontiere(p.prec_pt_sur_frontiere),
   fct_nD_bascul_contact_type_4(p.fct_nD_bascul_contact_type_4),
   penalisationPenetration(p.penalisationPenetration),
   fct_nD_penalisationPenetration(p.fct_nD_penalisationPenetration),
   penalisationTangentielle(p.penalisationTangentielle),
   fct_nD_penalisationTangentielle(p.fct_nD_penalisationTangentielle),
   typePenalisationPenetration(p.typePenalisationPenetration),
	  penetration_contact_maxi(p.penetration_contact_maxi),
   fct_nD_penetration_contact_maxi(p.fct_nD_penetration_contact_maxi),
   penetration_borne_regularisation(p.penetration_borne_regularisation),
   fct_nD_penetration_borne_regularisation(p.fct_nD_penetration_borne_regularisation),
	  force_contact_noeud_maxi(p.force_contact_noeud_maxi),
   fct_nD_force_contact_noeud_maxi(p.fct_nD_force_contact_noeud_maxi),
   typePenalisationTangentielle(p.typePenalisationTangentielle),
   tangentielle_contact_maxi(p.tangentielle_contact_maxi),
   fct_nD_tangentielle_contact_maxi(p.fct_nD_tangentielle_contact_maxi),
   tangentielle_borne_regularisation(p.tangentielle_borne_regularisation),
   fct_nD_tangentielle_borne_regularisation(p.fct_nD_tangentielle_borne_regularisation),
   force_tangentielle_noeud_maxi(p.force_tangentielle_noeud_maxi),
   fct_nD_force_tangentielle_noeud_maxi(p.fct_nD_force_tangentielle_noeud_maxi),
   nb_boucle_newton_position_frontiere(p.nb_boucle_newton_position_frontiere),
   nbDecolAutorise(p.nbDecolAutorise),typeDeDecolement(p.typeDeDecolement),nb_glissant(p.nb_glissant),
   niveau_commentaire_lescontacts(p.niveau_commentaire_lescontacts),
   niveau_commentaire_contact(p.niveau_commentaire_contact),
   fct_niveau_commentaire_contact(p.fct_niveau_commentaire_contact),
   optimisation_numerotation(p.optimisation_numerotation),
   point_interne_delta_thetai_maxi(p.point_interne_delta_thetai_maxi),
   point_interne_prec_thetai_interne(p.point_interne_prec_thetai_interne),
   point_interne_nb_boucle_sur_delta_thetai(p.point_interne_nb_boucle_sur_delta_thetai),
   point_interne_nb_externe(p.point_interne_nb_externe),
	  cal_vol_total_entre_surface_et_plans_ref(p.cal_vol_total_entre_surface_et_plans_ref),
   ratio_maxi_jacoMembrane_jacoPti(p.ratio_maxi_jacoMembrane_jacoPti),
	  type_calnum_inversion_metrique(p.type_calnum_inversion_metrique),
   sortieEquilibreGlobal(p.sortieEquilibreGlobal),
   sortieEtatActuelDansBI(p.sortieEtatActuelDansBI),
   sortieEtatActuelDansCVisu(p.sortieEtatActuelDansCVisu)
    {// pas de recopie des paramètre prec_pt_int_deb,extra_boite_prelocalisation car ils sont statics
   //   ParaGlob::Init_temps(tempo); // pas la peine car c'est une variable statique
    };

// Surcharge de l'affectation
ParaAlgoControle& ParaAlgoControle::operator= (const ParaAlgoControle& p)
  {   sauvegarde = p.sauvegarde; cas_de_sauvegarde = p.cas_de_sauvegarde;
      tempo_specifique_algo = p.tempo_specifique_algo;
      force_deltat = p.force_deltat;
      coef_pas_critique_deltatmaxi = p.coef_pas_critique_deltatmaxi;
      coef_pas_critique_deltatmini = p.coef_pas_critique_deltatmini;
      typeDFC_pas_critique_deltatmaxi = p.typeDFC_pas_critique_deltatmaxi;
      typeDFC_pas_critique_deltatmini = p.typeDFC_pas_critique_deltatmini;
      iterations = p.iterations;  precision = p.precision;
      norme = p.norme; //prectemps = p.prectemps;
      cinematique = p.cinematique; conv_forcee = p.conv_forcee;
      multiplicateur = p.multiplicateur; //deltat = p.deltat;
      coef_pas_critique_deltat = p.coef_pas_critique_deltat;
      typeDFC_pas_critique_deltat = p.typeDFC_pas_critique_deltat;
      maxincre = p.maxincre; //tempsfin = p.tempsfin;
      max_essai_incre = p.max_essai_incre;
      restart = p.restart; max_puissance = p.max_puissance;
      line_search = p.line_search; var_charge_externe = p.var_charge_externe;
      var_jacobien = p.var_jacobien; var_D = p.var_D;
      type_matrice = p.type_matrice; symetrie_matrice = p.symetrie_matrice;
      type_resolution = p.type_resolution;
      type_preconditionnement = p.type_preconditionnement;
      nb_iter_nondirecte = p.nb_iter_nondirecte;
      tolerance = p.tolerance; nb_vect_restart = p.nb_vect_restart;
      type_matrice_secondaire = p.type_matrice_secondaire;
      type_resolution_secondaire = p.type_resolution_secondaire;
      type_preconditionnement_secondaire = p.type_preconditionnement_secondaire;
      nb_iter_nondirecte_secondaire = p.nb_iter_nondirecte_secondaire;
      tolerance_secondaire = p.tolerance_secondaire; nb_vect_restart_secondaire = p.nb_vect_restart_secondaire;
      opti_pointeur_assemblage = p.opti_pointeur_assemblage;
      type_de_pilotage = p.type_de_pilotage; facteur_diminution = p.facteur_diminution;
      facteur_augmentation = p.facteur_augmentation; fact_dim_en_mauvaiseConv = p.fact_dim_en_mauvaiseConv;
      nb_bonne_convergence = p.nb_bonne_convergence;
      nb_iter_pour_bonne_convergence = p.nb_iter_pour_bonne_convergence;
      nb_iter_pour_mauvaise_convergence = p.nb_iter_pour_mauvaise_convergence;
      init_comp_tangent_simple = p.init_comp_tangent_simple;
      norme_incre_max = p.norme_incre_max; norme_incre_X_max = p.norme_incre_X_max;
      norme_incre_V_max = p.norme_incre_V_max;
      varMiniDdl = p.varMiniDdl; varMaxiDdl = p.varMaxiDdl;
      nbCycleControleResidu = p.nbCycleControleResidu; plageControleResidu = p.plageControleResidu;
      sur_sous_relaxation = p.sur_sous_relaxation; initIncreAvecDeltaDdlPrec = p.initIncreAvecDeltaDdlPrec;
      jabobien_negatif = p.jabobien_negatif; var_maxi_jacobien = p.var_maxi_jacobien;
      cas_fctnD_charge = p.cas_fctnD_charge;
      type_calcul_masse = p.type_calcul_masse;
      limitation_temps_maxi_stable = p.limitation_temps_maxi_stable;
      amort_visco_arti = p.amort_visco_arti; visco_arti = p.visco_arti;
      maxi_C_en_fonction_M = p.maxi_C_en_fonction_M;
      coef_rayleigh_masse = p.coef_rayleigh_masse; coef_rayleigh_raideur = p.coef_rayleigh_raideur;
      bulk_viscosity = p.bulk_viscosity; c_Tracebulk = p.c_Tracebulk; c_Trace2bulk = p.c_Trace2bulk;
      frequence_affichage_increment = p.frequence_affichage_increment;
      frequence_affichage_iteration = p.frequence_affichage_iteration;
      sortie_fil_calcul = p.sortie_fil_calcul;
      cas_de_sortie_fil_calcul = p.cas_de_sortie_fil_calcul;
      nb_diggit_double_calcul = p.nb_diggit_double_calcul;
      nb_diggit_double_graphique = p.nb_diggit_double_graphique;
      nb_diggit_double_ecran = p.nb_diggit_double_ecran;
      nb_incr_cal_ener = p.nb_incr_cal_ener;
      affiche_incr_energie = p.affiche_incr_energie;
      prec_pt_int_deb = p.prec_pt_int_deb; factPourRayonAccostage = p.factPourRayonAccostage;
      distanceMaxiAuPtProjete = p.distanceMaxiAuPtProjete;
      extra_boite_prelocalisation = p.extra_boite_prelocalisation;
      mini_extra_boite_prelocalisation = p.mini_extra_boite_prelocalisation;
      ajout_extra_boite_prelocalisation = p.ajout_extra_boite_prelocalisation;
      contact_type = p.contact_type; prec_pt_sur_frontiere = p.prec_pt_sur_frontiere;
      fct_nD_bascul_contact_type_4 = p.fct_nD_bascul_contact_type_4;
      penalisationPenetration = p.penalisationPenetration;
      fct_nD_penalisationPenetration = p.fct_nD_penalisationPenetration;
      
      penalisationTangentielle = p.penalisationTangentielle;
      fct_nD_penalisationPenetration = p.fct_nD_penalisationPenetration;

      typePenalisationPenetration = p.typePenalisationPenetration;
      penetration_contact_maxi = p.penetration_contact_maxi;
      fct_nD_penetration_contact_maxi = p.fct_nD_penetration_contact_maxi;
      
      penetration_borne_regularisation = p.penetration_borne_regularisation;
      fct_nD_penetration_borne_regularisation = p.fct_nD_penetration_borne_regularisation;

      force_contact_noeud_maxi = p.force_contact_noeud_maxi;
      fct_nD_force_contact_noeud_maxi = p.fct_nD_force_contact_noeud_maxi;

      typePenalisationTangentielle = p.typePenalisationTangentielle;
      tangentielle_contact_maxi = p.tangentielle_contact_maxi;
      fct_nD_tangentielle_contact_maxi = p.fct_nD_tangentielle_contact_maxi;

      tangentielle_borne_regularisation = p.tangentielle_borne_regularisation;
      fct_nD_tangentielle_borne_regularisation = p.fct_nD_tangentielle_borne_regularisation;

      force_tangentielle_noeud_maxi = p.force_tangentielle_noeud_maxi;
      fct_nD_force_tangentielle_noeud_maxi = p.fct_nD_force_tangentielle_noeud_maxi;

      nb_boucle_newton_position_frontiere = p.nb_boucle_newton_position_frontiere;
      nbDecolAutorise = p.nbDecolAutorise; typeDeDecolement = p.typeDeDecolement; nb_glissant = p.nb_glissant;
      
      niveau_commentaire_lescontacts = p.niveau_commentaire_lescontacts;
      niveau_commentaire_contact = p.niveau_commentaire_contact;
      fct_niveau_commentaire_contact = p.fct_niveau_commentaire_contact;
      
      optimisation_numerotation = p.optimisation_numerotation;
      point_interne_delta_thetai_maxi = p.point_interne_delta_thetai_maxi;
      point_interne_prec_thetai_interne = p.point_interne_prec_thetai_interne;
      point_interne_nb_boucle_sur_delta_thetai = p.point_interne_nb_boucle_sur_delta_thetai;
      point_interne_nb_externe = p.point_interne_nb_externe;
      cal_vol_total_entre_surface_et_plans_ref = p.cal_vol_total_entre_surface_et_plans_ref;
      ratio_maxi_jacoMembrane_jacoPti = p.ratio_maxi_jacoMembrane_jacoPti;
      type_calnum_inversion_metrique = p.type_calnum_inversion_metrique;
      sortieEquilibreGlobal = p.sortieEquilibreGlobal;
      sortieEtatActuelDansBI = p.sortieEtatActuelDansBI;
      sortieEtatActuelDansCVisu = p.sortieEtatActuelDansCVisu;
      
      return *this;  
  };
  

// Méthodes publiques
void ParaAlgoControle::Lecture_paraAlgoControle(UtilLecture & entreePrinc)
 { if (ParaGlob::NiveauImpression() > 5)
     cout << " debut de la lecture des parametres " << endl;
  MotCle motCle; // ref aux mots cle
  // on se positionne sur un mot cle
  while ( !motCle.SimotCle(entreePrinc.tablcar))
            entreePrinc.NouvelleDonnee();
  // def de variable logique disant si oui ou non il y a eu lecture d'un type de paramètre
  bool controle_lec=false; bool para_systeme_lineaire_lec = false;
  bool para_pilotage_equi_global_lec = false; bool para_dedies_dynamique_lec = false;
  bool para_affichage_lec = false;bool para_contact_lec = false; bool para_energie_lec = false; 
  bool para_calculs_geometriques_lec = false; bool lecture_max_essai_incre = false;
  // on lit tant qu'il s'agit d'un mot clé concernant les paramètres de contrôle
  while ((strstr(entreePrinc.tablcar,"controle")!=NULL) || 
         (strstr(entreePrinc.tablcar,"para_syteme_lineaire")!=NULL) ||
         (strstr(entreePrinc.tablcar,"para_pilotage_equi_global")!=NULL) ||   
         (strstr(entreePrinc.tablcar,"para_dedies_dynamique")!=NULL) ||   
         (strstr(entreePrinc.tablcar,"para_affichage")!=NULL)||
         (strstr(entreePrinc.tablcar,"para_contact")!=NULL)||
         (strstr(entreePrinc.tablcar,"para_energie")!=NULL)||
         (strstr(entreePrinc.tablcar,"para_calculs_geometriques")!=NULL) 
        ) 
   {  if (strstr(entreePrinc.tablcar,"controle")!=NULL)
       {controle_lec=true;
        // on lit jusqu'au prochain mot cle
        string nom;
        entreePrinc.NouvelleDonnee();
        while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "SAUVEGARDE")
               { // on regarde s'il y a une référence à un intervalle
                 if((strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
                    && (strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL))
                  {// cas où la sauvegarde est gérer en fonction d'un intervalle
                   cas_de_sauvegarde = 5; // enreg du type de gestion de sauvegarde
                   string nom1;
                   *(entreePrinc.entree) >>  nom >>  sauvegarde >> nom1;
                   if ((nom1 != "DERNIER_CALCUL") || (nom != "INTER_TEMPS"))
                    { cout << "\n *** erreur on a lu : "<< nom << ", au lieu de DERNIER_CALCUL "
                           << " ou alors on a lu : " << nom1 << ", au lieu de INTER_TEMPS !! ";
                      Sortie(1);
                    };
                  }
                 else if((strstr(entreePrinc.tablcar,"INTER_INCREMENT")!=NULL)
                    && (strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL))
                  {// cas où la sauvegarde est gérer en fonction d'un intervalle
                   cas_de_sauvegarde = 4; // enreg du type de gestion de sauvegarde
                   string nom1;
                   *(entreePrinc.entree) >>  nom >>  sauvegarde >> nom1;
                   if ((nom1 != "DERNIER_CALCUL") || (nom != "INTER_INCREMENT"))
                    { cout << "\n *** erreur on a lu : "<< nom << ", au lieu de DERNIER_CALCUL "
                           << " ou alors on a lu : " << nom1 << ", au lieu de INTER_INCREMENT !! ";
                      Sortie(1);
                    };
                  }
                 else if(strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL)
                  {// cas où la sauvegarde est gérer en fonction du dernier calcul
                   cas_de_sauvegarde = 3; // enreg du type de gestion de sauvegarde
                   *(entreePrinc.entree) >>  nom ; //>>  sauvegarde;
                  }
                 else if(strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
                  {// cas où la sauvegarde est gérer en fonction d'un intervale
                   cas_de_sauvegarde = 2; // enreg du type de gestion de sauvegarde
                   *(entreePrinc.entree) >>  nom ;
                   sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
                  }
                 else if(strstr(entreePrinc.tablcar,"INTER_INCREMENT")!=NULL)
                   {// cas où la sauvegarde est gérée par le nombre d'incréments
                    cas_de_sauvegarde = 1; // enreg du type de gestion de sauvegarde
                    *(entreePrinc.entree)  >>  nom ;
                    sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
                   }
                 else
                   {// cas où la sauvegarde est gérée par le nombre d'incréments
                    cas_de_sauvegarde = 1; // enreg du type de gestion de sauvegarde
                    sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
                   };
               }    
             else if (nom == "DELTAtMAXI")
               { // on regarde s'il y a une référence au pas critique
                 if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
                    // cas où c'est un coef du pas critique DFC
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltatmaxi=true; // pas critique DFC
                      *(entreePrinc.entree) >> toto ;
                      coef_pas_critique_deltatmaxi = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAtMAXI COEF_PASCRITIQUE_DFC ");
                    }
                 else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
                    // cas où c'est un coef du pas critique de la méthode
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltatmaxi=false; // pas critique spécifique
                      *(entreePrinc.entree) >> toto  ;
                      coef_pas_critique_deltatmaxi = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAtMAXI COEF_PASCRITIQUE ");
                    }
                 else
                    // sinon on lit directement le deltatmaxi
                    { tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
                          = entreePrinc.lect_avec_const_double_utilisateur("DELTAtMAXI ");
                    };
               }
             else if (nom == "DELTAtMINI")
               { // on regarde s'il y a une référence au pas critique
                 if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
                    // cas où c'est un coef du pas critique DFC
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltatmini=true; // pas critique DFC
                      *(entreePrinc.entree) >> toto  ;
                      coef_pas_critique_deltatmini = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAtMINI COEF_PASCRITIQUE_DFC ");
                    }
                 else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
                    // cas où c'est un coef du pas critique 
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltatmini=false; // pas critique DFC
                      *(entreePrinc.entree) >> toto ;
                      coef_pas_critique_deltatmini = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAtMINI COEF_PASCRITIQUE ");
                    }
                 else
                    // sinon on lit directement le deltatmaxi                    
                    { tempo_specifique_algo.deltatmini = tempo.deltatmini
                            = entreePrinc.lect_avec_const_double_utilisateur("DELTAtMINI  ");};
               }
             else if (nom == "ITERATIONS")
               { // on regarde les termes par défaut qui sont dépendants de cette valeur
				              bool changer1 = (nb_iter_pour_bonne_convergence == 0.25 * iterations);
					             bool changer2 = (nb_iter_pour_mauvaise_convergence == 0.5 * iterations);
					             // lecture de la nouvelle valeur
                  iterations = (int) entreePrinc.lect_avec_const_double_utilisateur("ITERATIONS ");
					             if (changer1)  nb_iter_pour_bonne_convergence = 0.25 * iterations;
					             if (changer2)  nb_iter_pour_mauvaise_convergence = 0.5 * iterations;
               } 
             else if (nom == "PRECISION")
               {precision = entreePrinc.lect_avec_const_double_utilisateur("PRECISION ");}
             else if (nom == "PRECTEMPS")
               {tempo_specifique_algo.prectemps = tempo.prectemps
                    = entreePrinc.lect_avec_const_double_utilisateur("PRECTEMPS ");}
             else if (nom == "MAX_PUISSANCE")
               {max_puissance= entreePrinc.lect_avec_const_double_utilisateur("MAX_PUISSANCE ");}
             else if (nom == "NORME")
               {*(entreePrinc.entree) >>  norme.nom1;
               
                if ( !(strstr(norme.nom1.c_str(),"Residu") || strstr(norme.nom1.c_str(),"Residu/Reaction")
                    || strstr(norme.nom1.c_str(),"Residu/PVExterne") || strstr(norme.nom1.c_str(),"Residu/PVInterne")
                    || strstr(norme.nom1.c_str(),"Residu/maxPVI")|| strstr(norme.nom1.c_str(),"min(Res,Res/Reaction)")
                    || strstr(norme.nom1.c_str(),"min(Res,Res/MaX(Reaction_et_PVExterne))")
                    || strstr(norme.nom1.c_str(),"E_cinetique/E_statique_ET_ResSurReact")
                    || strstr(norme.nom1.c_str(),"E_cinetique/E_statique_ET_Res/Reac_et_Fext")
                    || strstr(norme.nom1.c_str(),"E_cin/E_stat_ET_min(Res,Res/Reac_et_Fext)")
                    || strstr(norme.nom1.c_str(),"E_cinetique")
						              || strstr(norme.nom1.c_str(),"Bilan_puissance/Max(puiss)")
                    || strstr(norme.nom1.c_str(),"Residu/Reaction_et_Residu")
                    || strstr(norme.nom1.c_str(),"fonction_nD:")
						             ))              
                   { cout << "\n ** erreur en lecture du type de norme pour le controle"
                          << " d\'algorithme, nom lu : "<<  norme;
                     entreePrinc.MessageBuffer
                       ("** lecture des parametres de controle **");
                     Affiche();
                     throw (UtilLecture::ErrNouvelleDonnee(-1));
                     Sortie (1);
                   };
                // s'il s'agit du nom d'une fonction nD on la récupère
                if (norme.nom1 == "fonction_nD:")
                  *(entreePrinc.entree) >>  norme.nom2;
               }
             else if (nom == "CINEMATIQUE")
               {cinematique = (bool) entreePrinc.lect_avec_const_double_utilisateur("CINEMATIQUE ");
               }
             else if (nom == "CONV_FORCEE")
               {conv_forcee = (bool) entreePrinc.lect_avec_const_double_utilisateur("CONV_FORCEE ");
               }
             else if (nom == "MULTIPLICATEUR")
               {multiplicateur = entreePrinc.lect_avec_const_double_utilisateur("MULTIPLICATEUR ");
               }
             else if (nom == "DELTAt")
               { // on regarde s'il y a une référence au pas critique
                  if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
                    // cas où c'est un coef du pas critique DFC
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltat=true; // pas critique DFC
                      *(entreePrinc.entree) >> toto ;
                      coef_pas_critique_deltat = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAt COEF_PASCRITIQUE_DFC ");
                    }
                  else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
                    // cas où c'est un coef du pas critique 
                    { //on passe la chaine de caractère et on lit le coeff
                      string toto;
                      typeDFC_pas_critique_deltat=false; // pas critique DFC
                      *(entreePrinc.entree) >> toto ;
                      coef_pas_critique_deltat = entreePrinc.lect_avec_const_double_utilisateur
                         ("DELTAt COEF_PASCRITIQUE ");
                    }
                  else
                    // sinon on lit directement le deltat                    
                    {tempo_specifique_algo.deltat = tempo.deltat
                             = entreePrinc.lect_avec_const_double_utilisateur("DELTAt ");
                    };
                  // on regarde si l'on veut forcer la reprise du pas de temps donné dans le .info
                  // par rapport à celle du fichier de restart si il existe
                  if(strstr(entreePrinc.tablcar,"FORCE_DELTAT_DU_.INFO")!=NULL)
                    force_deltat=true; else force_deltat=false;
               }
             else if (nom == "TEMPSFIN")
               {tempo_specifique_algo.tempsfin = tempo.tempsfin
                      = entreePrinc.lect_avec_const_double_utilisateur("TEMPSFIN ");
               }
             else if (nom == "MAXINCRE")
               {maxincre = (int) entreePrinc.lect_avec_const_double_utilisateur("MAXINCRE ");
               }
             else if (nom == "MAX_ESSAI_INCRE")
               {max_essai_incre= (int) entreePrinc.lect_avec_const_double_utilisateur("MAX_ESSAI_INCRE ");
                lecture_max_essai_incre = true; // du coup le max_essai_incre ne prendra
               } // pas la valeur par défaut qui est celle de maxincre
             else if (nom == "RESTART")
               {restart= (int) entreePrinc.lect_avec_const_double_utilisateur("RESTART ");
               }
             else if (nom == "LINE_SEARCH")
               {line_search = true;}
             else if (nom == "VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR")
               {var_charge_externe = (bool) entreePrinc.lect_avec_const_double_utilisateur
                    ("VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR ");
               }
             else if (nom == "VARIATION_JACOBIEN_SUR_RAIDEUR")
               {var_jacobien = (bool) entreePrinc.lect_avec_const_double_utilisateur
                    ("VARIATION_JACOBIEN_SUR_RAIDEUR ");
               }
             else if (nom == "VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR")
               {var_D = (bool) entreePrinc.lect_avec_const_double_utilisateur
                    ("VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR ");
               }
             else
               { cout << "\n ** erreur en lecture de parametre de controle"
                          << " d\'algorithme, nom lu : "<< nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres de controle **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               };
             entreePrinc.NouvelleDonnee();              
           };
       };
      // ensuite on s'occupe du sytème lineaire général
      if (strstr(entreePrinc.tablcar,"para_syteme_lineaire")!=NULL)
        { para_systeme_lineaire_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "TYPE_MATRICE")
                {*(entreePrinc.entree) >> type_matrice ;}
             else if (nom == "SYMETRIE_MATRICE")
                {symetrie_matrice= (bool) entreePrinc.lect_avec_const_double_utilisateur("SYMETRIE_MATRICE ");
                }
             else if (nom == "TYPE_RESOLUTION")
                {*(entreePrinc.entree) >>  type_resolution;}
             else if (nom == "TYPE_PRECONDITIONNEMENT")
                {*(entreePrinc.entree) >>  type_preconditionnement;}
             else if (nom == "NB_ITER_NONDIRECTE")
                {nb_iter_nondirecte = (int) entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_NONDIRECTE ");
                }
             else if (nom == "TOLERANCE")
                {tolerance =  entreePrinc.lect_avec_const_double_utilisateur("TOLERANCE ");
                }
             else if (nom == "NB_VECT_RESTART")
                {nb_vect_restart = (int) entreePrinc.lect_avec_const_double_utilisateur("NB_VECT_RESTART ");}
             else if (nom == "MATRICE_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires on lit tout d'abort les types de matrices
                type_matrice_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_TYPE_MAT_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_TYPE_MAT_SECONDAIRES_")
                     type_matrice_secondaire.push_back(Id_nom_matrice(nom));
                 };
               }
             else if (nom == "TYPE_RESOLUTION_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires lecture du type de résolution
                type_resolution_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_TYPE_RESOLUTION_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_TYPE_RESOLUTION_SECONDAIRES_")
                     type_resolution_secondaire.push_back(Id_nom_resolution(nom));
                 };
               }
             else if (nom == "TYPE_PRECONDITIONNEMENT_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires lecture du type de préconditionnement
                type_preconditionnement_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_TYPE_PRECONDITIONNEMENT_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_TYPE_PRECONDITIONNEMENT_SECONDAIRES_")
                     type_preconditionnement_secondaire.push_back(Id_nom_preconditionnement(nom));
                 };
               }
             else if (nom == "NB_ITER_NONDIRECTE_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires lecture du nombre d'itération
                nb_iter_nondirecte_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_NB_ITER_NONDIRECTE_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_NB_ITER_NONDIRECTE_SECONDAIRES_")
                      nb_iter_nondirecte_secondaire.push_back(ChangeEntier(nom));
                 };
               }
             else if (nom == "TOLERANCE_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires lecture du type de préconditionnement
                tolerance_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_TOLERANCE_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_TOLERANCE_SECONDAIRES_")
                     tolerance_secondaire.push_back(ChangeReel(nom));
                 };
               }
             else if (nom == "NB_VECT_RESTART_S_SECONDAIRE_S_")
               {// dans le cas de matrices secondaires lecture du type de préconditionnement
                nb_vect_restart_secondaire.clear(); // on vide d'abord la liste déjà existante
                while (nom != "FIN_NB_VECT_RESTART_SECONDAIRES_")
                 { *(entreePrinc.entree) >>  nom;
                   if (nom != "FIN_NB_VECT_RESTART_SECONDAIRES_")
                     nb_vect_restart_secondaire.push_back(ChangeEntier(nom));
                 };
               }
             else if (nom == "OPTIMISATION_POINTEURS_ASSEMBLAGE")
               {opti_pointeur_assemblage= (int) entreePrinc.lect_avec_const_double_utilisateur("OPTIMISATION_POINTEURS_ASSEMBLAGE ");}
             else
               { cout << "\n ** erreur en lecture de parametres"
                      << " pour le système linéaire, nom lu : "<< nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres du systeme lineaire **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               };
             entreePrinc.NouvelleDonnee();              
            } 
         };
    
      // 3) ensuite on s'occupe des paramètres de pilotage de l'équilibre global
      if (strstr(entreePrinc.tablcar,"para_pilotage_equi_global")!=NULL)
        { para_pilotage_equi_global_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "FACTEUR_DIMINUTION")
                  facteur_diminution= entreePrinc.lect_avec_const_double_utilisateur("FACTEUR_DIMINUTION ");
             else if (nom == "FACTEUR_AUGMENTATION")
                  facteur_augmentation= entreePrinc.lect_avec_const_double_utilisateur("FACTEUR_AUGMENTATION ");
             else if (nom == "NB_BONNE_CONVERGENCE")
                  nb_bonne_convergence= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_BONNE_CONVERGENCE ");
             else if (nom == "FACT_DIM_EN_MAUVAISE_CONVERGENCE")
                  fact_dim_en_mauvaiseConv= entreePrinc.lect_avec_const_double_utilisateur("FACT_DIM_EN_MAUVAISE_CONVERGENCE ");
             else if (nom == "NB_ITER_POUR_BONNE_CONVERGENCE")
                  nb_iter_pour_bonne_convergence= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_POUR_BONNE_CONVERGENCE ");
             else if (nom == "NB_ITER_POUR_MAUVAISE_CONVERGENCE")
                  nb_iter_pour_mauvaise_convergence= (int)entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_POUR_MAUVAISE_CONVERGENCE ");
             else if (nom == "INIT_COMP_TANGENT_SIMPLE")
                  init_comp_tangent_simple= entreePrinc.lect_avec_const_double_utilisateur("INIT_COMP_TANGENT_SIMPLE ");
             else if (nom == "SUR_SOUS_RELAXATION")
                  sur_sous_relaxation= entreePrinc.lect_avec_const_double_utilisateur("SUR_SOUS_RELAXATION ");
             else if (nom == "NORME_MAXI_INCREMENT")
                  norme_incre_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_INCREMENT ");
             else if (nom == "NORME_MAXI_X_INCREMENT")
                  norme_incre_X_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_X_INCREMENT ");
             else if (nom == "NORME_MAXI_V_INCREMENT")
                  norme_incre_V_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_V_INCREMENT ");
             else if (nom == "MAXI_VARIATION_DDL_POUR_CONVERGENCE")
                  varMaxiDdl= entreePrinc.lect_avec_const_double_utilisateur("MAXI_VARIATION_DDL_POUR_CONVERGENCE ");
             else if (nom == "MINI_VARIATION_DDL_POUR_CONVERGENCE")
                  varMiniDdl= entreePrinc.lect_avec_const_double_utilisateur("MINI_VARIATION_DDL_POUR_CONVERGENCE ");
             else if (nom == "NB_CYCLE_CONTROLE_RESIDU")
                  nbCycleControleResidu= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CYCLE_CONTROLE_RESIDU ");
             else if (nom == "PLAGE_CONTROLE_RESIDU")
                  plageControleResidu= (int) entreePrinc.lect_avec_const_double_utilisateur("PLAGE_CONTROLE_RESIDU ");
             else if (nom == "INIT_INCRE_AVEC_PAS_PREC")
                  initIncreAvecDeltaDdlPrec= entreePrinc.lect_avec_const_double_utilisateur("INIT_INCRE_AVEC_PAS_PREC ");
             else if (nom == "CAS_JACOBIEN_NEGATIF")
                  jabobien_negatif= (int) entreePrinc.lect_avec_const_double_utilisateur("CAS_JACOBIEN_NEGATIF ");
             else if (nom == "VAR_MAXI_JACOBIEN")
                  var_maxi_jacobien= entreePrinc.lect_avec_const_double_utilisateur("VAR_MAXI_JACOBIEN ");
             else if (nom == "CAS_PB_FCTND_CHARGE")
                  cas_fctnD_charge= entreePrinc.lect_avec_const_double_utilisateur("CAS_PB_FCTND_CHARGE ");
             else if (nom == "TYPE_DE_PILOTAGE")
                  *(entreePrinc.entree) >> type_de_pilotage; 
             else
               { cout << "\n ** erreur en lecture de parametres"
                      << " pour le pilotage de l'equilibre global, nom lu : "<< nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres du pilotage de l'equilibre global **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
            } 
         } 
      // 4) ensuite on s'occupe des paramètres liés à la dynamique  
      if (strstr(entreePrinc.tablcar,"para_dedies_dynamique")!=NULL)
        { para_dedies_dynamique_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "TYPE_CALCUL_MATRICE_MASSE")
               {// lecture du type
                 *(entreePrinc.entree) >> nom;
                 if (nom == "MASSE_DIAG_COEF_EGAUX")
                  type_calcul_masse = MASSE_DIAG_COEF_EGAUX;
                 else if (nom == "MASSE_DIAG_COEF_VAR")
                  type_calcul_masse = MASSE_DIAG_COEF_VAR;
                 else if (nom == "MASSE_CONSISTANTE")
                  type_calcul_masse = MASSE_CONSISTANTE;
                 else
                  { cout << "\n ** erreur en lecture de parametres"
                         << " pour le type de matrice de masse, type  lu : "<< nom;
                    entreePrinc.MessageBuffer
                          ("** lecture des donnees lie à la dynamique **");
                    Affiche();
                    throw (UtilLecture::ErrNouvelleDonnee(-1));
                    Sortie (1);
                   }
                }
             else if (nom == "LIMITATION_TEMPS_MAXI_STABLE")
               {// lecture du booléen
                 limitation_temps_maxi_stable= (bool) entreePrinc.lect_avec_const_double_utilisateur("LIMITATION_TEMPS_MAXI_STABLE ");
                }
             else if (nom == "AMORTISSEMENT_VISCOSITE_ARTIFICIELLE")
               {// lecture du cas d'amortissement
                 amort_visco_arti= (int) entreePrinc.lect_avec_const_double_utilisateur("AMORTISSEMENT_VISCOSITE_ARTIFICIELLE ");
                }
             else if (nom == "VISCOSITE_ARTIFICIELLE")
               {// lecture de la viscosité ou de la proportion de viscosité critique
                 visco_arti=  entreePrinc.lect_avec_const_double_utilisateur("VISCOSITE_ARTIFICIELLE ");
                }
             else if (nom == "MAXI_C_EN_FONCTION_M")
               {// bornage de C critique
                 maxi_C_en_fonction_M= entreePrinc.lect_avec_const_double_utilisateur("MAXI_C_EN_FONCTION_M ");
                }
             else if (nom == "COEFFICIENT_DE_RAYLEIGH_POUR_LA_MASSE")
               {// lecture du coefficient
                 coef_rayleigh_masse= entreePrinc.lect_avec_const_double_utilisateur("COEFFICIENT_DE_RAYLEIGH_POUR_LA_MASSE ");
                }
             else if (nom == "COEFFICIENT_DE_RAYLEIGH_POUR_LA_RAIDEUR")
               {// lecture du coefficient
                 coef_rayleigh_raideur= entreePrinc.lect_avec_const_double_utilisateur("COEFFICIENT_DE_RAYLEIGH_POUR_LA_RAIDEUR ");
                }                
             else if (nom == "BULK_VISCOSITY")
               {// lecture du choix
                 bulk_viscosity= (int) entreePrinc.lect_avec_const_double_utilisateur("BULK_VISCOSITY ");
                }
             else if (nom == "COEFF_TRACE")
               {// lecture du coefficient
                 c_Tracebulk= entreePrinc.lect_avec_const_double_utilisateur("COEFF_TRACE ");
                }
             else if (nom == "COEFF_CARRE_TRACE")
               {// lecture du coefficient
                 c_Trace2bulk= entreePrinc.lect_avec_const_double_utilisateur("COEFF_CARRE_TRACE ");
                }
             else 
               { cout << "\n ** erreur en lecture de parametres"
                      << " pour les donnees lie à la dynamique, nom lu : "<< nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des donnees lie à la dynamique **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
            } 
         } 
         
      // 5) paramètres liès à l'affichage des résultats 
      if (strstr(entreePrinc.tablcar,"para_affichage")!=NULL)
        { para_affichage_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "FREQUENCE_AFFICHAGE_INCREMENT")
               frequence_affichage_increment= (int) entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_AFFICHAGE_INCREMENT ");
             else if (nom == "FREQUENCE_AFFICHAGE_ITERATION")
               frequence_affichage_iteration= (int) entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_AFFICHAGE_ITERATION ");
             else if (nom == "FREQUENCE_SORTIE_FIL_DU_CALCUL")
               { // on regarde s'il y a une référence au pas critique
                 if(strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
                  {// cas où la sauvegarde est gérer en fonction d'un pas de temps
                   cas_de_sortie_fil_calcul = 2; // enreg du type de gestion de sauvegarde
                   *(entreePrinc.entree) >>  nom ;
                   sortie_fil_calcul= entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_SORTIE_FIL_DU_CALCUL ");
                   }
                 else if(strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL)
                  {// cas où la sauvegarde est gérer en fonction du dernier calcul
                   cas_de_sortie_fil_calcul = 3; // enreg du type de gestion de sauvegarde
                   *(entreePrinc.entree) >>  nom ; // passage du nom
						             sortie_fil_calcul =1000000; // grand
                  }
                 else
                  {// cas où la sauvegarde est gérée par le nombre d'incréments
                   cas_de_sortie_fil_calcul = 1; // enreg du type de gestion de sauvegarde
                   sortie_fil_calcul= entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_SORTIE_FIL_DU_CALCUL ");
                   // si la fréquence est nulle ou négative
                   if (sortie_fil_calcul <= 0)sortie_fil_calcul =-1000000;
                  };
               }
             else if (nom == "NB_CHIFFRE_POUR_DOUBLE_CALCUL")
               nb_diggit_double_calcul= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_CALCUL ");
             else if (nom == "NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE")
               nb_diggit_double_graphique= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE ");
             else if (nom == "NB_CHIFFRE_POUR_DOUBLE_ECRAN")
               nb_diggit_double_ecran= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_ECRAN ");
             else
               { cout << "\n ** erreur en lecture des parametres d'affichage" << nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres des parametres d'affichage **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
            } 
         } 
         
      // 6) paramètres liès au contact 
      if (strstr(entreePrinc.tablcar,"para_contact")!=NULL)
        { para_contact_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom; string nom_inter;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "PRECISION_POINT_INTERNE_DEBUT")
               {prec_pt_int_deb= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_POINT_INTERNE_DEBUT ");}
             else if (nom == "FACT_POUR_RAYON_ACCOSTAGE")
               {factPourRayonAccostage= entreePrinc.lect_avec_const_double_utilisateur("FACT_POUR_RAYON_ACCOSTAGE ");}
				         else if (nom == "DISTANCE_MAXI_AU_PT_PROJETE")
				           {distanceMaxiAuPtProjete= entreePrinc.lect_avec_const_double_utilisateur("DISTANCE_MAXI_AU_PT_PROJETE ");}
             else if (nom == "PRECISION_BOITE_PRELOCALISATION")
               {extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_BOITE_PRELOCALISATION ");}
             else if (nom == "MINI_EXTRA_BOITE_PRELOCALISATION")
               {mini_extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("MINI_EXTRA_BOITE_PRELOCALISATION ");}
             else if (nom == "AJOUT_EXTRA_BOITE_PRELOCALISATION")
               {ajout_extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("AJOUT_EXTRA_BOITE_PRELOCALISATION ");}
             else if (nom == "CONTACT_TYPE")
               {contact_type= (int) entreePrinc.lect_avec_const_double_utilisateur("CONTACT_TYPE ");}
             else if (nom == "FCT_ND_BASCUL_CONTACT_TYPE_4")
               {*(entreePrinc.entree) >> fct_nD_bascul_contact_type_4;}
             else if (nom == "PENALISATION_PENETRATION")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_PENALISATION_PENETRATION")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_penalisationPenetration;
                  penalisationPenetration = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {penalisationPenetration= entreePrinc.lect_avec_const_double_utilisateur("PENALISATION_PENETRATION ");
                  fct_nD_penalisationPenetration = "_";
                 }
               }
             else if (nom == "TYPE_PENALISATION_PENETRATION")
               {typePenalisationPenetration= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_PENALISATION_PENETRATION ");}
             else if (nom == "PENETRATION_CONTACT_MAXI")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_PENETRATION_CONTACT_MAXI")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_penetration_contact_maxi;
                  penetration_contact_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {penetration_contact_maxi= entreePrinc.lect_avec_const_double_utilisateur("PENETRATION_CONTACT_MAXI ");
                  penetration_contact_maxi=Dabs(penetration_contact_maxi);
                  fct_nD_penetration_contact_maxi = "_";
                 }
               }
             else if (nom == "PENETRATION_BORNE_REGULARISATION")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_PENETRATION_BORNE_REGULARISATION")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_penetration_borne_regularisation;
                  penetration_borne_regularisation = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {penetration_borne_regularisation= entreePrinc.lect_avec_const_double_utilisateur("PENETRATION_BORNE_REGULARISATION ");
                  penetration_borne_regularisation=Dabs(penetration_borne_regularisation);
                  fct_nD_penetration_borne_regularisation = "_";
                 }
               }
             else if (nom == "FORCE_CONTACT_NOEUD_MAXI")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_FORCE_CONTACT_NOEUD_MAXI")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_force_contact_noeud_maxi;
                  force_contact_noeud_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {force_contact_noeud_maxi= entreePrinc.lect_avec_const_double_utilisateur("FORCE_CONTACT_NOEUD_MAXI ");
                  force_contact_noeud_maxi=Dabs(force_contact_noeud_maxi);
                  fct_nD_force_contact_noeud_maxi = "_";
                 }
               }
             else if (nom == "PENALISATION_TANGENTIELLE")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_PENALISATION_TANGENTIELLE")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_penalisationTangentielle;
                  penalisationTangentielle = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {penalisationTangentielle= entreePrinc.lect_avec_const_double_utilisateur("PENALISATION_TANGENTIELLE ");
                  fct_nD_penalisationTangentielle = "_";
                 }
               }
              else if (nom == "TYPE_PENALISATION_TANGENTIELLE")
               {typePenalisationTangentielle= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_PENALISATION_TANGENTIELLE ");}
             else if (nom == "TANGENTIELLE_CONTACT_MAXI")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_TANGENTIELLE_CONTACT_MAXI")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_tangentielle_contact_maxi;
                  tangentielle_contact_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {tangentielle_contact_maxi= entreePrinc.lect_avec_const_double_utilisateur("TANGENTIELLE_CONTACT_MAXI ");
                  tangentielle_contact_maxi=Dabs(tangentielle_contact_maxi);
                  fct_nD_tangentielle_contact_maxi = "_";
                 }
               }
             else if (nom == "TANGENTIELLE_BORNE_REGULARISATION")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_TANGENTIELLE_BORNE_REGULARISATION")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_tangentielle_borne_regularisation;
                  tangentielle_borne_regularisation = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {tangentielle_borne_regularisation= entreePrinc.lect_avec_const_double_utilisateur("TANGENTIELLE_BORNE_REGULARISATION ");
                  tangentielle_borne_regularisation=Dabs(tangentielle_borne_regularisation);
                  fct_nD_tangentielle_borne_regularisation = "_";
                 }
               }
             else if (nom == "FORCE_TANGENTIELLE_NOEUD_MAXI")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI")!=NULL)
                 {*(entreePrinc.entree) >> nom_inter >> fct_nD_force_tangentielle_noeud_maxi;
                  force_tangentielle_noeud_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
                 }
                else
                 {force_tangentielle_noeud_maxi= entreePrinc.lect_avec_const_double_utilisateur("FORCE_TANGENTIELLE_NOEUD_MAXI ");
                  force_tangentielle_noeud_maxi=Dabs(force_tangentielle_noeud_maxi);
                  fct_nD_force_tangentielle_noeud_maxi = "_";
                 }
               }
             else if (nom == "PRECISION_PT_SUR_FRONTIERE")
               {prec_pt_sur_frontiere= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_PT_SUR_FRONTIERE ");}
             else if (nom == "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE")
               {nb_boucle_newton_position_frontiere= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE ");}
             else if (nom == "NB_DECOLLEMENT_MAXI")
               {nbDecolAutorise= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_DECOLLEMENT_MAXI ");}
				         else if (nom == "TYPE_DE_DECOLLEMENT")
				           {typeDeDecolement= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_DE_DECOLLEMENT ");}
             else if (nom == "NB_MOY_GLISSANT")
               {nb_glissant= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_MOY_GLISSANT ");}
             else if (nom == "NIVEAU_COMMENTAIRE_LESCONTACTS")
               {niveau_commentaire_lescontacts= (int) entreePrinc.lect_avec_const_double_utilisateur("NIVEAU_COMMENTAIRE_LESCONTACTS ");
               }
             else if (nom == "NIVEAU_COMMENTAIRE_CONTACT")
               {if (strstr(entreePrinc.tablcar,"FCT_ND_NIVEAU_COMMENTAIRE_CONTACT")!=NULL)
                  {*(entreePrinc.entree) >> nom_inter >> fct_niveau_commentaire_contact;
                   niveau_commentaire_contact = -1; // valeur négative arbitraire
                  }
                else
                  {niveau_commentaire_contact= (int) entreePrinc.lect_avec_const_double_utilisateur("NIVEAU_COMMENTAIRE_CONTACT ");
                   fct_niveau_commentaire_contact = "_";
                  };
                }
             else if (nom == "OPTIMISATION_NUMEROTATION")
               {optimisation_numerotation= (int) entreePrinc.lect_avec_const_double_utilisateur("OPTIMISATION_NUMEROTATION ");}
             else
               { cout << "\n ** erreur en lecture des parametres de contact" << nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres des parametres de contact **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
           };
         } 
         
      // 7) paramètres liés aux calculs des énergies
      if (strstr(entreePrinc.tablcar,"para_energie")!=NULL)
        { para_energie_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "CALCUL_ENERGIE")
               {double calcul_energie;
                *(entreePrinc.entree) >> calcul_energie;
                 cout << "\n warning CALCUL_ENERGIE est un parametre obsolete, le calcul est maintenant systematique " 
                 << endl;
               }
             else if (nom == "NB_INCR_CAL_ENERG")
               nb_incr_cal_ener= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_INCR_CAL_ENERG ");
             else if (nom == "AFFICHE_INCR_ENERGIE")
               affiche_incr_energie= (bool) entreePrinc.lect_avec_const_double_utilisateur("AFFICHE_INCR_ENERGIE ");
             else
               { cout << "\n ** erreur en lecture des parametres sur l'energie" << nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres des parametres sur l'energie **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
            } 
         }; 
         
      // 8) paramètres liés aux calculs géométriques sur les éléments
      if (strstr(entreePrinc.tablcar,"para_calculs_geometriques")!=NULL)
        { para_calculs_geometriques_lec = true; // on signal qu'il y a lecture
          // on lit jusqu'au prochain mot cle
          string nom;
          entreePrinc.NouvelleDonnee();
          while ( !motCle.SimotCle(entreePrinc.tablcar)) 
           { *(entreePrinc.entree) >> nom;
             if (nom == "POINT_INTERNE_DELTA_THETAI_MAXI")
               {point_interne_delta_thetai_maxi= entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_DELTA_THETAI_MAXI ");}
             else if (nom == "POINT_INTERNE_PREC_THETAI_INTERNE")
               {point_interne_prec_thetai_interne= entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_PREC_THETAI_INTERNE ");}
             else if (nom == "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI")
               {point_interne_nb_boucle_sur_delta_thetai= (int) entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI ");}
             else if (nom == "POINT_INTERNE_NB_EXTERNE")
               {point_interne_nb_externe= (int) entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_NB_EXTERNE ");}
             else if (nom == "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF")
               {cal_vol_total_entre_surface_et_plans_ref= (bool) entreePrinc.lect_avec_const_double_utilisateur("CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF ");}
             else if (nom == "RATIO_MAXI_JACOMEMBRANE_JACOPTI" )
               {ratio_maxi_jacoMembrane_jacoPti= entreePrinc.lect_avec_const_double_utilisateur("RATIO_MAXI_JACOMEMBRANE_JACOPTI ");}
             else if (nom == "TYPE_CALNUM_INVERSION_METRIQUE")
               { *(entreePrinc.entree) >>  type_calnum_inversion_metrique;}
             else
               { cout << "\n ** erreur en lecture des parametres de calculs geometrique: mot cle inconnu : " << nom;
                 entreePrinc.MessageBuffer
                       ("** lecture des parametres des parametres sur l'energie **");
                 Affiche();
                 throw (UtilLecture::ErrNouvelleDonnee(-1));
                 Sortie (1);
               }
             entreePrinc.NouvelleDonnee();              
            } 
         } 

   }; // fin de la lecture tant qu'il y a un mot clé relatif à la lecture de paramètres
   // affichage d'information concernant les paramètres
   if ((ParaGlob::NiveauImpression() >= 4 ) && (ParaGlob::param->EtatDeLaLecturePointInfo()==0))
     { if (!controle_lec)
        { cout << "\n lecture des parametres de controle  ";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
       if (!para_systeme_lineaire_lec)
        { cout << "\n lecture des parametres pour le syteme lineaire  ";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
       if (!para_pilotage_equi_global_lec)
        { cout << "\n ** lecture des parametres du pilotage de l'equilibre global **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
       if (!para_dedies_dynamique_lec)
        { cout << "\n ** lecture des parametres parametres lies a la dynamique **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
       if (!para_affichage_lec)
        { cout << "\n ** lecture des parametres parametres lies a l'affichage **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
       if (!para_contact_lec)
        { cout << "\n ** lecture des parametres parametres lies au contact **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
         } 
       if (!para_energie_lec)
        { cout << "\n ** lecture des parametres parametres lies aux energies **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
         } 
       if (!para_calculs_geometriques_lec)
        { cout << "\n ** lecture des parametres parametres lies aux calculs geometriques **";
          cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
        };
     };
   if ((ParaGlob::NiveauImpression() > 0 ) && (ParaGlob::param->EtatDeLaLecturePointInfo()> 0))
     { if (controle_lec)
         cout << "\n relecture de certains(s) parametre(s) de controle  " << flush;
       if (para_systeme_lineaire_lec)
         cout << "\n relecture de certains(s) parametre(s) pour le syteme lineaire  " << flush;
       if (para_pilotage_equi_global_lec)
         cout << "\n ** relecture de certains(s) parametre(s) du pilotage de l'equilibre global **" << flush;
       if (para_dedies_dynamique_lec)
         cout << "\n ** relecture de certains(s) parametre(s) lies a la dynamique **" << flush;
       if (para_affichage_lec)
         cout << "\n ** relecture de certains(s) parametre(s) lies a l'affichage **" << flush;
       if (para_contact_lec)
         cout << "\n ** relecture de certains(s) parametre(s) lies au contact **" << flush;
       if (para_energie_lec)
         cout << "\n ** relecture de certains(s) parametre(s) lies aux energies **" << flush;
       if (para_calculs_geometriques_lec)
         cout << "\n ** relecture de certains(s) parametre(s) lies aux calculs geometriques **" << flush;
     };

   if (ParaGlob::NiveauImpression() >= 4 )
     { // vérification sur les paramètres temps
       if (tempo.deltatmaxi < tempo.deltatmini)
         { cout << "\n ***erreur en lecture des parametres de controle du temps: deltat maxi "
                << tempo.deltatmaxi << " est inferieur eu deltat mini " << tempo.deltatmini;
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie (1);
         };
       if (tempo.deltatmini < 0.)
         { cout << "\n ***erreur en lecture des parametres de controle du temps: deltat mini est negatif:  "
                << tempo.deltatmini;
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie (1);
         };
     };
   // particularité liée au paramètre max_essai_incre
   if (!lecture_max_essai_incre)     // s'il n'y a pas eu de lecture du paramètre max_essai_incre
      max_essai_incre = maxincre;  // on le met à la valeur par défaut = maxincre
    
   if (ParaGlob::NiveauImpression() >= 4)
     cout << " \n fin de la lecture des parametres " << endl;
 };

    // sauvegarde propre de l'élément sur base info
    // cas donne le niveau de sauvegarde
    // = 1 : on sauvegarde tout
    // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
    // incre : numero d'incrément auquel on sauvegarde 
    // éventuellement est définit de manière spécifique pour chaque algorithme
    // dans les classes filles
void ParaAlgoControle::Ecriture_base_info_Para
             (ofstream& sort,const int cas) const
 {// dans le cas particulier de cette classe il n'y a que les paramètres
  // du calcul qu'il faut sauvegarder
  sort << "\n";
  switch (cas)
  { case 1 : // ------- on sauvegarde tout -------------------------
    {// 1)  parametres de controle généraux pour la résolution de l'équilibre
     //     générale
     sort << "PARAMETRES_DU_CALCUL_:\n";
     sort << "frequence_de_sauvegarde " <<  sauvegarde << "\n";  
     sort << "casDeGestion_de_sauvegarde " <<  cas_de_sauvegarde << "\n";  
     sort << "force_deltat_du_point_info " <<  force_deltat << "\n";
     sort << "coef_pas_critique_deltatmaxi " <<  coef_pas_critique_deltatmaxi << "\n";
     sort << "coef_pas_critique_deltatmini " <<  coef_pas_critique_deltatmini << "\n";
     sort << "typeDFC_pas_critique_deltatmaxi " <<  typeDFC_pas_critique_deltatmaxi << "\n";
     sort << "typeDFC_pas_critique_deltatmini " <<  typeDFC_pas_critique_deltatmini << "\n";
     sort << "maxi_d'iteration_pour_converger " <<  iterations << "\n";
     sort << "precision_de_la_convergence " <<  precision << "\n"; 
//     sort << "precision_sur_le_temps_final " <<  tempo.prectemps << "\n";
     sort << "type_de_norme_de_convergence " <<  norme << "\n";
     sort << "cinematique_sur_l'increment " <<  cinematique << "\n";
     sort << "convergence_forcee " <<  conv_forcee << "\n";
     sort << "multiplicateur_de_la_charge " <<  multiplicateur << "\n";
//     sort << "increment_de_temps " <<  tempo.deltat << "\n"; 
     sort << "coef_pas_critique_deltat " <<  coef_pas_critique_deltat << "\n"; 
     sort << "typeDFC_pas_critique_deltat " <<  typeDFC_pas_critique_deltat << "\n"; 
//     sort << "temps_de_fin_de_calcul " <<  tempo.tempsfin << "\n"; 
     sort << "maximum_d'increment_de_temps " <<  maxincre << "\n";
     sort << "maximum_d'essai_d'increment_de_temps " <<  max_essai_incre << "\n";
     sort << "increment_de_redemarage_de_calcul " <<  restart << "\n";
     sort << "maximum_de_puissance " <<  max_puissance << "\n";
     sort << "utilisation_du_line_search  "  <<  line_search << '\n';
     sort << "var_charge_externe  "  <<  var_charge_externe << '\n';
     sort << "var_jacobien  "  <<  var_jacobien << '\n';
     sort << "var_D  "  <<  var_D << '\n';
       // sauvegarde du temps
     tempo_specifique_algo.Ecriture_base_info_temps(sort,cas);
            
     // 2) paramètres liés au systèmes d'équation linéairelinéaire
     sort << "PARAMETRES_SYSTEM_LINEAIRE_:\n";
     sort << "type_de_matrice " <<  type_matrice << "\n";  
     sort << "symetrie_matrice " <<  symetrie_matrice << "\n";  
     sort << "type_de_resolution " <<  type_resolution << "\n";
     sort << "type_de_preconditionnement " <<  type_preconditionnement << "\n";
     sort << "nombre_iteration_non_directe " <<  nb_iter_nondirecte << "\n"; 
     sort << "tolerance_resol_non_directe " <<  tolerance << "\n";
     sort << "nb_vecteur_restart " <<  nb_vect_restart << "\n";
     // maintenant les listes pour les matrices secondaires si nécessaire
     sort << " liste_pour_matrice_secondaire_ \n ";
     if (!type_matrice_secondaire.empty())
      { sort << "type_matrice_secondaire(s)_taille: " << type_matrice_secondaire.size() << " \n";
        list < Enum_matrice >::const_iterator ili,ili_end=type_matrice_secondaire.end();
        for (ili = type_matrice_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     
     if (!type_resolution_secondaire.empty())
      { sort << "type_resolution_secondaire(s)_taille: " << type_resolution_secondaire.size() << " \n";
        list < Enum_type_resolution_matri >::const_iterator ili,ili_end=type_resolution_secondaire.end();
        for (ili = type_resolution_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     
     if (!type_preconditionnement_secondaire.empty())
      { sort << "type_preconditionnement_secondaire(s)_taille: " << type_preconditionnement_secondaire.size() << " \n";
        list < Enum_preconditionnement >::const_iterator ili,ili_end=type_preconditionnement_secondaire.end();
        for (ili = type_preconditionnement_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     
     if (!nb_iter_nondirecte_secondaire.empty())
      { sort << "nb_iter_nondirecte_secondaire(s)_taille: " << nb_iter_nondirecte_secondaire.size() << " \n";
        list < int >::const_iterator ili,ili_end=nb_iter_nondirecte_secondaire.end();
        for (ili = nb_iter_nondirecte_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     
     if (!tolerance_secondaire.empty())
      { sort << "tolerance_secondaire(s)_taille: " << tolerance_secondaire.size() << " \n";
        list < double >::const_iterator ili,ili_end=tolerance_secondaire.end();
        for (ili = tolerance_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     
     if (!nb_vect_restart_secondaire.empty())
      { sort << "nb_vect_restart_secondaire(s)_taille: " << nb_vect_restart_secondaire.size() << " \n";
        list < int >::const_iterator ili,ili_end=nb_vect_restart_secondaire.end();
        for (ili = nb_vect_restart_secondaire.begin();ili != ili_end;ili++)
           sort << " " << (*ili) ;
        sort << "\n";
      };
     sort << " fin_liste_pour_matrice_secondaire_ \n ";
     sort << "OPTIMISATION_POINTEURS_ASSEMBLAGE " << opti_pointeur_assemblage << "\n";

     // 3) paramètres liés au pilotage de l'équilibre global
     sort << "PARAMETRES_PILOTAGE_EQUILIBRE_GLOBAL:\n";
     sort << "typ_de_pilotage " << Nom_TypePilotage(type_de_pilotage) << "\n";
     sort << "facteur_diminution " << facteur_diminution << "\n";
     sort << "facteur_augmentation " << facteur_augmentation << "\n";
     sort << "nb_bonne_convergence " << nb_bonne_convergence << "\n";                   
     sort << "fact_dim_en_mauvaiseConv " << fact_dim_en_mauvaiseConv << "\n";                   
     sort << "nb_iter_pour_bonne_convergence " << nb_iter_pour_bonne_convergence << "\n";                   
     sort << "nb_iter_pour_mauvaise_convergence " << nb_iter_pour_mauvaise_convergence << "\n";                   
     sort << "init_comp_tangent_simple " << init_comp_tangent_simple << "\n";                   
     sort << "sur_sous_relaxation " << sur_sous_relaxation << "\n";                   
     sort << "norme_maxi_increment " << norme_incre_max << "\n";                   
     sort << "norme_maxi_X_increment " << norme_incre_X_max << "\n";
     sort << "norme_maxi_V_increment " << norme_incre_V_max << "\n";
     sort << "maxi_variation_ddl_pour_convergence " << varMaxiDdl << "\n";
     sort << "mini_variation_ddl_pour_convergence " << varMiniDdl << "\n";  
     sort << "nb_cycle_controle_residu " << nbCycleControleResidu << "\n";  
     sort << "plage_controle_residu " << plageControleResidu << "\n";  
     sort << "init_incre_avec_pas_prec " << initIncreAvecDeltaDdlPrec << "\n";  
     sort << "jabobien_negatif " << jabobien_negatif << "\n";  
     sort << "var_maxi_jacobien " << var_maxi_jacobien << "\n";  
     sort << "cas_fctnD_charge " << cas_fctnD_charge << "\n";
     // 4) paramètres liès à la dynamique
     sort << "PARAMETRES_DEDIES_DYNAMIQUE:\n";
     sort << "type_calcul_masse " << type_calcul_masse << "\n";
     sort << "limitation_temps_maxi_stable " << limitation_temps_maxi_stable << "\n";
     sort << "amorti_visco_artificielle " << amort_visco_arti << "\n";
     sort << "coeff_visco_artificielle " << visco_arti << "\n";
     sort << "maxi_C_en_fonction_M " << maxi_C_en_fonction_M << "\n";
     sort << "coeff_rayleigh_masse " << coef_rayleigh_masse << "\n";
     sort << "coeff_rayleigh_raideur " << coef_rayleigh_raideur << "\n";
     sort << "bulk_viscosity " << bulk_viscosity << "\n";
     sort << "c_Tracebulk " << c_Tracebulk << "\n";
     sort << "c_Trace2bulk " << c_Trace2bulk << "\n";
     // 5) paramètres liès à l'affichage des résultats 
     sort << "PARAMETRES_AFFICHAGE:\n";
     sort << "FREQUENCE_AFFICHAGE_INCREMENT " << frequence_affichage_increment << "\n"; 
     sort << "FREQUENCE_AFFICHAGE_ITERATION " << frequence_affichage_iteration << "\n"; 
     sort << "FREQUENCE_SORTIE_FIL_DU_CALCUL " << sortie_fil_calcul << "\n"; 
     sort << "CAS_DE_FREQUENCE_SORTIE_FIL_CALCUL " << cas_de_sortie_fil_calcul << "\n";
     sort << "NB_CHIFFRE_POUR_DOUBLE_CALCUL " << nb_diggit_double_calcul << "\n"; 
     sort << "NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE " << nb_diggit_double_graphique << "\n"; 
     sort << "NB_CHIFFRE_POUR_DOUBLE_ECRAN " << nb_diggit_double_ecran << "\n";
     // 6) paramètres liès au contact
     sort << "PARAMETRES_CONTACT:\n";
     sort << "PRECISION_POINT_INTERNE_DEBUT " << prec_pt_int_deb << "\n"; 
     sort << "FACT_POUR_RAYON_ACCOSTAGE " << factPourRayonAccostage << "\n"; 
	    sort << "DISTANCE_MAXI_AU_PT_PROJETE " << distanceMaxiAuPtProjete << "\n";
     sort << "PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation << "\n"; 
     sort << "MINI_EXTRA_BOITE_PRELOCALISATION " << mini_extra_boite_prelocalisation << "\n";
     sort << "AJOUT_EXTRA_BOITE_PRELOCALISATION " << ajout_extra_boite_prelocalisation << "\n";
     sort << "CONTACT_TYPE " << contact_type << "\n"; 
     sort << "FCT_ND_BASCUL_CONTACT_TYPE_4 " << fct_nD_bascul_contact_type_4 << "\n";
     sort << "PENALISATION_PENETRATION " << penalisationPenetration
          << "FCT_ND_PENALISATION_PENETRATION"<< fct_nD_penalisationPenetration <<"\n";
     sort << "TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration << "\n";      
     sort << "PENETRATION_CONTACT_MAXI " << penetration_contact_maxi
          << "FCT_ND_PENETRATION_CONTACT_MAXI"<< fct_nD_penetration_contact_maxi <<"\n";
     sort << "PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation
          << "FCT_ND_PENETRATION_BORNE_REGULARISATION"<< fct_nD_penetration_borne_regularisation <<"\n";
     sort << "FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi
          << "FCT_ND_FORCE_CONTACT_NOEUD_MAXI"<< fct_nD_force_contact_noeud_maxi <<"\n";
     sort << "PENALISATION_TANGENTIELLE " << penalisationTangentielle
          << "FCT_ND_PENALISATION_TANGENTIELLE"<< fct_nD_penalisationTangentielle <<"\n";
     sort << "TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle << "\n";
     sort << "TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi
          << "FCT_ND_TANGENTIELLE_CONTACT_MAXI"<< fct_nD_tangentielle_contact_maxi <<"\n";
     sort << "TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation
          << "FCT_ND_TANGENTIELLE_BORNE_REGULARISATION"<< fct_nD_tangentielle_borne_regularisation <<"\n";
     sort << "FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi
          << "FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI"<< fct_nD_force_tangentielle_noeud_maxi <<"\n";

     sort << "PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere << "\n";
     sort << "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere << "\n"; 
     sort << "NB_DECOLLEMENT_MAXI " << nbDecolAutorise << "\n"; 
	    sort << "TYPE_DE_DECOLLEMENT " << typeDeDecolement << "\n";
     sort << "NB_MOY_GLISSANT " << nb_glissant << "\n";
     sort << "NIVEAU_COMMENTAIRE_LESCONTACTS "<< niveau_commentaire_lescontacts << "\n";
     sort << "NIVEAU_COMMENTAIRE_CONTACT "<< niveau_commentaire_contact
          << "FCT_ND_NIVEAU_COMMENTAIRE_CONTACT"<< fct_niveau_commentaire_contact << "\n";
     sort << "OPTIMISATION_NUMEROTATION "<< optimisation_numerotation << "\n";

     // 7) paramètres liès aux énergies
     sort << "PARAMETRES_ENERGIES:\n";
     sort << "NB_INCR_CAL_ENERG " << nb_incr_cal_ener << "\n"; 
     sort << "AFFICHE_INCR_ENERGIE " << affiche_incr_energie << "\n"; 
     // 8) paramètres liés aux calculs géométriques sur les éléments
     sort << "PARAMETRES_CALCULS_GEOMETRIQUES:\n";
     sort << "POINT_INTERNE_DELTA_THETAI_MAXI " << point_interne_delta_thetai_maxi << "\n"; 
     sort << "POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne << "\n"; 
     sort << "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai << "\n"; 
     sort << "POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe << "\n"; 
     sort << "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF " << cal_vol_total_entre_surface_et_plans_ref << "\n"; 
     sort << "RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti << "\n";
     sort << "TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique << "\n";
     sort << flush;
	 break;
	 }
    case  2 : // ----------- sauvegarde uniquement de se qui varie --------------------
    {// paramètres relatifs au temps    
     tempo_specifique_algo.Ecriture_base_info_temps(sort,cas);
     break;
     }
   }     
  };
    // cas de la lecture spécifique à l'algorithme dans base_info
void ParaAlgoControle::Lecture_base_info_Para(ifstream& ent,const int cas)
{ // dans le cas particulier de cette classe il n'y a que les paramètres
  // du calcul qu'il faut lire
  switch (cas)
  { case 1 :   // lecture complète   
    {string toto;
     ent  >> toto;
     ent  >> toto >>  sauvegarde ;  
     ent  >> toto >>  cas_de_sauvegarde ;  
     ent  >> toto >>  force_deltat ;
     ent  >> toto >>  coef_pas_critique_deltatmaxi ;
     ent  >> toto >>  coef_pas_critique_deltatmini ;
     ent  >> toto >>  typeDFC_pas_critique_deltatmaxi ;
     ent  >> toto >>  typeDFC_pas_critique_deltatmini ;
     ent  >> toto >>  iterations ;
     ent  >> toto >>  precision ; 
     ent  >> toto >>  norme ;
     ent  >> toto >>  cinematique ;
     ent  >> toto >>  conv_forcee ;
     ent  >> toto >>  multiplicateur ;
     ent  >> toto >>  coef_pas_critique_deltat ; 
     ent  >> toto >>  typeDFC_pas_critique_deltat ; 
     ent  >> toto >>  maxincre ;
     ent  >> toto >>  max_essai_incre ;
     ent  >> toto >>  restart ;
     ent  >> toto >>  max_puissance ;
     ent  >> toto >>  line_search ;
     ent  >> toto >>  var_charge_externe ;
     ent  >> toto >>  var_jacobien ;
     ent  >> toto >>  var_D ;
       // lecture du temps
     tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
     
     // 2) paramètres liés au systèmes d'équation linéairelinéaire
     ent  >> toto ;
     ent  >> toto >> type_matrice  ;  
     ent  >> toto >> symetrie_matrice  ;  
     ent  >> toto >> type_resolution ;
     ent  >> toto >> type_preconditionnement ;
     ent  >> toto >> nb_iter_nondirecte  ; 
     ent  >> toto >> tolerance  ;
     ent  >> toto >> nb_vect_restart  ;
     
     // maintenant les listes pour les matrices secondaires si nécessaire
     ent  >> toto ; // passage du mot clé
     while (toto != "fin_liste_pour_matrice_secondaire_")
      { ent  >> toto ; // on lit le mot clé
        if (toto == "type_matrice_secondaire(s)_taille:")
         { type_matrice_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              type_matrice_secondaire.push_back(Id_nom_matrice(toto));
            };
         }
       else if (toto == "type_resolution_secondaire(s)_taille:")
         { type_resolution_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              type_resolution_secondaire.push_back(Id_nom_resolution(toto));
            };
         }
       else if (toto == "type_preconditionnement_secondaire(s)_taille:")
         { type_preconditionnement_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              type_preconditionnement_secondaire.push_back(Id_nom_preconditionnement(toto));
            };
         }
       else if (toto == "nb_iter_nondirecte_secondaire(s)_taille:")
         { nb_iter_nondirecte_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              nb_iter_nondirecte_secondaire.push_back(ChangeEntier(toto));
            };
         }
       else if (toto == "tolerance_secondaire(s)_taille:")
         { tolerance_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              tolerance_secondaire.push_back(ChangeReel(toto));
            };
         }
       else if (toto == "nb_vect_restart_secondaire(s)_taille:")
         { nb_vect_restart_secondaire.clear(); // on vide la liste
           int taille = 0;
           ent >> taille;
           for (int i=1;i<=taille;i++)
            { ent >> toto;
              nb_vect_restart_secondaire.push_back(ChangeEntier(toto));
            };
         }
       else if (toto == "fin_liste_pour_matrice_secondaire_")
        { } // on ne fait rien c'est ok
       else
        {cout << "\n erreur en lecture des listes pour matrices secondaires: "
              << " on a lu: "<< toto << " et on ne sait pas quoi en faire !! "
              << "\n ParaAlgoControle::Lecture_base_info_Para(.. "
              << endl;
         Sortie(1);
        };
      };
     ent  >> toto >>  opti_pointeur_assemblage;

     
     // 3) paramètres liés au pilotage de l'équilibre global
     ent  >> toto ;
     ent  >> toto >>  facteur_diminution;
     ent  >> toto >>  type_de_pilotage;
     ent  >> toto >>  facteur_augmentation;
     ent  >> toto >>  nb_bonne_convergence;                   
     ent  >> toto >>  fact_dim_en_mauvaiseConv;                   
     ent  >> toto >>  nb_iter_pour_bonne_convergence;                   
     ent  >> toto >>  nb_iter_pour_mauvaise_convergence;                   
     ent  >> toto >>  init_comp_tangent_simple;                   
     ent  >> toto >>  sur_sous_relaxation;                   
     ent  >> toto >>  norme_incre_max;                   
     ent  >> toto >>  norme_incre_X_max;
     ent  >> toto >>  norme_incre_V_max;
     ent  >> toto >>  varMaxiDdl;
     ent  >> toto >>  varMiniDdl;                   
     ent  >> toto >> nbCycleControleResidu ;  
     ent  >> toto >> plageControleResidu ;  
     ent  >> toto >> initIncreAvecDeltaDdlPrec ;  
     ent  >> toto >> jabobien_negatif ;  
     ent  >> toto >> var_maxi_jacobien ;  
     ent  >> toto >> cas_fctnD_charge ;
     // 4) paramètres liès à la dynamique
     ent  >> toto ;
     ent  >> toto >>   type_calcul_masse ;
     ent  >> toto >>   limitation_temps_maxi_stable ;
     ent  >> toto >>   amort_visco_arti ;
     ent  >> toto >>   visco_arti ;
     ent  >> toto >>   maxi_C_en_fonction_M ;
     ent  >> toto >>   coef_rayleigh_masse ;
     ent  >> toto >>   coef_rayleigh_raideur ;
     ent  >> toto >>   bulk_viscosity ;
     ent  >> toto >>   c_Tracebulk ;
     ent  >> toto >>   c_Trace2bulk ;
     // 5) paramètres liès à l'affichage des résultats 
     ent  >> toto ;
     ent  >> toto >>   frequence_affichage_increment ; 
     ent  >> toto >>   frequence_affichage_iteration ; 
     ent  >> toto >>   sortie_fil_calcul ; 
     ent  >> toto >>   cas_de_sortie_fil_calcul ; 
     ent  >> toto >>   nb_diggit_double_calcul ; 
     ent  >> toto >>   nb_diggit_double_graphique ; 
     ent  >> toto >>   nb_diggit_double_ecran ;
     // 6) paramètres liès au contact
     ent  >> toto ;
     ent  >> toto >>   prec_pt_int_deb ; 
     ent  >> toto >>   factPourRayonAccostage ;
	    ent  >> toto >>   distanceMaxiAuPtProjete; 
     ent  >> toto >>   extra_boite_prelocalisation ; 
     ent  >> toto >>   mini_extra_boite_prelocalisation ; 
     ent  >> toto >>   ajout_extra_boite_prelocalisation ;
     ent  >> toto >>   contact_type ;
     ent  >> toto >>   fct_nD_bascul_contact_type_4 ;
     ent  >> toto >>   penalisationPenetration >> toto >> fct_nD_penalisationPenetration;
     ent  >> toto >>   typePenalisationPenetration ; 
     ent  >> toto >>   penetration_contact_maxi >> toto >> fct_nD_penetration_contact_maxi ;
     ent  >> toto >>   penetration_borne_regularisation >> toto >> fct_nD_penetration_borne_regularisation;
     ent  >> toto >>   force_contact_noeud_maxi >> toto >> fct_nD_force_contact_noeud_maxi;
     ent  >> toto >>   penalisationTangentielle >> toto >> fct_nD_penalisationTangentielle;
     ent  >> toto >>   typePenalisationTangentielle ;
     ent  >> toto >>   tangentielle_contact_maxi >> toto >> fct_nD_tangentielle_contact_maxi ;
     ent  >> toto >>   tangentielle_borne_regularisation >> toto >> fct_nD_tangentielle_borne_regularisation;
     ent  >> toto >>   force_tangentielle_noeud_maxi >> toto >> fct_nD_force_tangentielle_noeud_maxi ;
     ent  >> toto >>   prec_pt_sur_frontiere ;
     ent  >> toto >>   nb_boucle_newton_position_frontiere ; 
     ent  >> toto >>   nbDecolAutorise ; 
	    ent  >> toto >>   typeDeDecolement ;
	    ent  >> toto >>   nb_glissant ;
     ent  >> toto >>   niveau_commentaire_lescontacts;
     ent  >> toto >>   niveau_commentaire_contact  >> toto >> fct_niveau_commentaire_contact;
     ent  >> toto >>   optimisation_numerotation;
     // 7) paramètres liès aux énergies
     ent  >> toto ;
     ent  >> toto >>   nb_incr_cal_ener ; 
     ent  >> toto >>   affiche_incr_energie ; 
     // 8) paramètres liés aux calculs géométriques sur les éléments
     ent  >> toto ;
     ent  >> toto >>   point_interne_delta_thetai_maxi ; 
     ent  >> toto >>   point_interne_prec_thetai_interne ; 
     ent  >> toto >>   point_interne_nb_boucle_sur_delta_thetai ; 
     ent  >> toto >>   point_interne_nb_externe ; 
     ent  >> toto >>   cal_vol_total_entre_surface_et_plans_ref ; 
     ent  >> toto >>   ratio_maxi_jacoMembrane_jacoPti ;
     ent  >> toto >>   type_calnum_inversion_metrique ;
     break;
	   }
    case  2 : // lecture uniquement de ce qui varie
    {// lecture du temps
     if (force_deltat && (restart!=0))
       { // cas du premier passage, et d'un restart
         // cas ou on veut forcer l'état de deltat à la valeur du .info (ou autre valeur initiale)
         double sauve_deltat = tempo_specifique_algo.deltat; // sauvegarde de la valeur initiale
         tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
         tempo_specifique_algo.deltat = sauve_deltat; // récup de la valeur précédente
         force_deltat = false;
         tempo = tempo_specifique_algo;
       }
     else
       {// cas courant
        tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
        tempo = tempo_specifique_algo;
       };
	    break;
    };
  } // -- fin du switch
};

// affichage des parametres de controle de l'algorithme
// et affichage des paramètres liés à la résolution du système linéaire
void ParaAlgoControle::Affiche()  const 
  { 
    // 1)  parametres de controle généraux pour la résolution de l'équilibre
    //     générale
    cout << "\n  parametres de controle de l'algorithmes \n";
    cout << "frequence de sauvegarde          = " <<  sauvegarde << '\n';
    cout << "casDeGestion_de_sauvegarde       = " <<  cas_de_sauvegarde << '\n';
    cout << "force deltat du point info       = " <<  force_deltat << '\n';
    cout << "coef pas_critique pour deltatmaxi= " <<  coef_pas_critique_deltatmaxi << '\n';
    cout << "coef pas_critique pour deltatmini= " <<  coef_pas_critique_deltatmini << '\n';
    cout << "type pas_critique DFC pour deltatmaxi= " <<  typeDFC_pas_critique_deltatmaxi << '\n';
    cout << "type pas_critique DFC pour deltatmini= " <<  typeDFC_pas_critique_deltatmini << '\n';
    cout << "maxi d'iteration pour converger  = " <<  iterations << '\n';
    cout << "precision de la convergence      = " <<  precision << '\n';
//    cout << "precision sur le temps final     = " <<  tempo.prectemps << '\n';
    cout << "type de norme de convergence     = " <<  norme << '\n';
    cout << "cinematique sur l'increment      = " <<  cinematique << '\n';
    cout << "convergence forcee               = " <<  conv_forcee << '\n';
    cout << "multiplicateur de la charge      = " <<  multiplicateur << '\n';
//    cout << "increment de temps               = " <<  tempo.deltat << '\n';
//    cout << "temps de fin de calcul           = " <<  tempo.tempsfin << '\n';
    cout << "maximum d'increment de temps     = " <<   maxincre << '\n';
    cout << "maximum d'essai d'increment      = " <<   max_essai_incre << '\n';
    cout << "increment de redemarage de calcul = " <<  restart << '\n';
    cout << "maximum de puissance             = "  <<  max_puissance << '\n';
    cout << "utilisation du line_search       = "  <<  line_search << '\n';
    cout << "var_charge_externe               = "  <<  var_charge_externe << '\n';
    cout << "var_jacobien                     = "  <<  var_jacobien << '\n';
    cout << "var_D                            = "  <<  var_D << '\n';
      // affichage des paramètres liés au temps
    tempo_specifique_algo.Affiche();
    // 2) paramètres liés au systèmes d'équation linéaire
    cout << "PARAMETRES_SYSTEM_LINEAIRE_:\n";
    cout << "type de matrice " <<  type_matrice << "\n";  
    cout << "symetrie de l'assemblage " <<  symetrie_matrice << "\n";  
    cout << "type de resolution " <<  type_resolution << "\n";
    cout << "type de preconditionnement " <<  type_preconditionnement << "\n";
    cout << "nombre iteration non directe " <<  nb_iter_nondirecte << "\n"; 
    cout << "tolerance resol non directe " <<  tolerance << "\n";
    cout << "nb vecteur restart " <<  nb_vect_restart << "\n";
    // maintenant les listes pour les matrices secondaires si nécessaire
    if (!type_matrice_secondaire.empty())
     { cout << "type_matrice_secondaire(s)_taille: " << type_matrice_secondaire.size() << " \n";
       list < Enum_matrice >::const_iterator ili,ili_end=type_matrice_secondaire.end();
       for (ili = type_matrice_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    
    if (!type_resolution_secondaire.empty())
     { cout << "type_resolution_secondaire(s)_taille: " << type_resolution_secondaire.size() << " \n";
       list < Enum_type_resolution_matri >::const_iterator ili,ili_end=type_resolution_secondaire.end();
       for (ili = type_resolution_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    
    if (!type_preconditionnement_secondaire.empty())
     { cout << "type_preconditionnement_secondaire(s)_taille: " << type_preconditionnement_secondaire.size() << " \n";
       list < Enum_preconditionnement >::const_iterator ili,ili_end=type_preconditionnement_secondaire.end();
       for (ili = type_preconditionnement_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    
    if (!nb_iter_nondirecte_secondaire.empty())
     { cout << "nb_iter_nondirecte_secondaire(s)_taille: " << nb_iter_nondirecte_secondaire.size() << " \n";
       list < int >::const_iterator ili,ili_end=nb_iter_nondirecte_secondaire.end();
       for (ili = nb_iter_nondirecte_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    
    if (!tolerance_secondaire.empty())
     { cout << "tolerance_secondaire(s)_taille: " << tolerance_secondaire.size() << " \n";
       list < double >::const_iterator ili,ili_end=tolerance_secondaire.end();
       for (ili = tolerance_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    
    if (!nb_vect_restart_secondaire.empty())
     { cout << "nb_vect_restart_secondaire(s)_taille: " << nb_vect_restart_secondaire.size() << " \n";
       list < int >::const_iterator ili,ili_end=nb_vect_restart_secondaire.end();
       for (ili = nb_vect_restart_secondaire.begin();ili != ili_end;ili++)
          cout << " " << (*ili) ;
       cout << "\n";
     };
    cout << "OPTIMISATION_POINTEURS_ASSEMBLAGE" << opti_pointeur_assemblage << "\n";

   
     // 3) paramètres liés au pilotage de l'équilibre global
    cout << "PARAMETRES_PILOTAGE_EQUILIBRE_GLOBAL:\n";
    cout << "typ_de_pilotage " << Nom_TypePilotage(type_de_pilotage) << "\n";
    cout << "facteur_diminution" << facteur_diminution << "\n";
    cout << "facteur_augmentation" << facteur_augmentation << "\n";
    cout << "nb_bonne_convergence" << nb_bonne_convergence << "\n";                   
    cout << "fact_dim_en_mauvaiseConv" << fact_dim_en_mauvaiseConv << "\n";                   
    cout << "nb_iter_pour_bonne_convergence" << nb_iter_pour_bonne_convergence << "\n";                   
    cout << "nb_iter_pour_mauvaise_convergence " << nb_iter_pour_mauvaise_convergence << "\n";                   
    cout << "init_comp_tangent_simple" << init_comp_tangent_simple << "\n";                   
    cout << "sur_sous_relaxation" << sur_sous_relaxation << "\n";                   
    cout << "norme_maxi_increment" << norme_incre_max << "\n";                   
    cout << "norme_maxi_X_increment" << norme_incre_X_max << "\n";
    cout << "norme_maxi_V_increment" << norme_incre_V_max << "\n";
    cout << "maxi_variation_ddl_pour_convergence " << varMaxiDdl << "\n";
    cout << "mini_variation_ddl_pour_convergence " << varMiniDdl << "\n";  
    cout << "nb_cycle_controle_residu " << nbCycleControleResidu << "\n";  
    cout << "plage_controle_residu " << plageControleResidu << "\n";  
    cout << "init_incre_avec_pas_prec " << initIncreAvecDeltaDdlPrec << "\n";  
    cout << "jabobien_negatif " << jabobien_negatif << "\n";  
    cout << "var_maxi_jacobien " << var_maxi_jacobien << "\n";  
    cout << "cas_fctnD_charge " << cas_fctnD_charge << "\n";
     // 4) paramètres liès à la dynamique
    cout << "PARAMETRES_DEDIES_DYNAMIQUE:\n";
    cout << "type_calcul_masse" << type_calcul_masse << "\n";
    cout << "limitation_temps_maxi_stable" << limitation_temps_maxi_stable << "\n";
    cout << "amorti_visco_artificielle " << amort_visco_arti << "\n";
    cout << "coeff_visco_artificielle " << visco_arti << "\n";
    cout << "maxi_C_en_fonction_M " << maxi_C_en_fonction_M << "\n";
    cout << "coeff_rayleigh_masse " << coef_rayleigh_masse << "\n";
    cout << "coeff_rayleigh_raideur " << coef_rayleigh_raideur << "\n";    
    cout << "bulk_viscosity " << bulk_viscosity << "\n";
    cout << "c_Tracebulk " << c_Tracebulk << "\n";
    cout << "c_Trace2bulk " << c_Trace2bulk << "\n";
     // 5) paramètres liès à l'affichage des résultats 
    cout << "PARAMETRES_AFFICHAGE:\n";
    cout << "frequence_affichage_increment " << frequence_affichage_increment << "\n"; 
    cout << "frequence_affichage_iteration " << frequence_affichage_iteration << "\n"; 
    cout << "sortie_fil_calcul " << sortie_fil_calcul << "\n"; 
    cout << "CAS_DE_SORTIE_FIL_CALCUL " << cas_de_sortie_fil_calcul << "\n";
    cout << "nb_chiffre_pour_double_calcul " << nb_diggit_double_calcul << "\n"; 
    cout << "nb_chiffre_pour_double_graphique " << nb_diggit_double_graphique << "\n"; 
    cout << "nb_chiffre_pour_double_ecran " << nb_diggit_double_ecran << "\n";
     // 6) paramètres liès au contact
    cout << "PARAMETRES_CONTACT:\n";
    cout << "PRECISION_POINT_INTERNE_DEBUT " << prec_pt_int_deb << "\n"; 
    cout << "FACT_POUR_RAYON_ACCOSTAGE " << factPourRayonAccostage << "\n"; 
	   cout << "DISTANCE_MAXI_AU_PT_PROJETE" << distanceMaxiAuPtProjete << "\n";
    cout << "PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation << "\n"; 
    cout << "MINI_EXTRA_BOITE_PRELOCALISATION " << mini_extra_boite_prelocalisation << "\n"; 
    cout << "AJOUT_EXTRA_BOITE_PRELOCALISATION " << ajout_extra_boite_prelocalisation << "\n";
    cout << "CONTACT_TYPE " << contact_type << "\n";
    cout << "FCT_ND_BASCUL_CONTACT_TYPE_4 " << fct_nD_bascul_contact_type_4 << "\n";
    cout << "PENALISATION_PENETRATION " << penalisationPenetration
         << "FCT_ND_PENALISATION_PENETRATION"<< fct_nD_penalisationPenetration <<"\n";
    cout << "TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration << "\n";
    cout << "PENETRATION_CONTACT_MAXI " << penetration_contact_maxi
         << "FCT_ND_PENETRATION_CONTACT_MAXI"<< fct_nD_penetration_contact_maxi << "\n";
    cout << "PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation
         << "FCT_ND_PENETRATION_BORNE_REGULARISATION"<< fct_nD_penetration_borne_regularisation << "\n";
    cout << "FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi
         << "FCT_ND_FORCE_CONTACT_NOEUD_MAXI"<< fct_nD_force_contact_noeud_maxi  << "\n";
    cout << "PENALISATION_TANGENTIELLE " << penalisationTangentielle
         << "FCT_ND_PENALISATION_TANGENTIELLE"<< fct_nD_penalisationTangentielle << "\n";
    cout << "TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle << "\n";
    cout << "TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi
         << "FCT_ND_TANGENTIELLE_CONTACT_MAXI"<< fct_nD_tangentielle_contact_maxi << "\n";
    cout << "TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation
         << "FCT_ND_TANGENTIELLE_BORNE_REGULARISATION"<< fct_nD_tangentielle_borne_regularisation << "\n";
    cout << "FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi
         << "FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI"<< fct_nD_force_tangentielle_noeud_maxi << "\n";
    cout << "PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere << "\n";
    cout << "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere << "\n"; 
    cout << "NB_DECOLLEMENT_MAXI " << nbDecolAutorise << "\n";
	   cout << "TYPE_DE_DECOLLEMENT " << typeDeDecolement << "\n"; 
    cout << "NB_MOY_GLISSANT " << nb_glissant << "\n";
    cout << "NIVEAU_COMMENTAIRE_LESCONTACTS " << niveau_commentaire_lescontacts << "\n";
    cout << "NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact
         << "FCT_ND_NIVEAU_COMMENTAIRE_CONTACT"<< fct_niveau_commentaire_contact << "\n";
    cout << "OPTIMISATION_NUMEROTATION " << optimisation_numerotation << "\n";
     // 7) paramètres liès aux énergies
    cout  << "PARAMETRES_ENERGIES:\n";
    cout  << "NB_INCR_CAL_ENERG " << nb_incr_cal_ener << "\n"; 
    cout  << "AFFICHE_INCR_ENERGIE " << affiche_incr_energie << "\n"; 
     // 8) paramètres liés aux calculs géométriques sur les éléments
    cout  << "PARAMETRES_CALCULS_GEOMETRIQUES:\n";
    cout  << "POINT_INTERNE_DELTA_THETAI_MAXI " << point_interne_delta_thetai_maxi << "\n"; 
    cout  << "POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne << "\n"; 
    cout  << "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai << "\n"; 
    cout  << "POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe << "\n"; 
    cout  << "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF " << cal_vol_total_entre_surface_et_plans_ref << "\n";
    cout  << "RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti << "\n";
    cout  << "TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique << "\n"; 
   };
      
// affichage et definition interactive des commandes
void ParaAlgoControle::Info_commande_ParaAlgoControle(UtilLecture& entreePrinc)
  {
   ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
   //On va proposer un menu
   string rep=" ";
   cout  << "\n   --- definition des parametres de controle ------       ";
   while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
      {
       try 
        { 
        cout << "\n choix du groupe de controle : "
           << "\n [c] -> para tres classique [-] para assez courants "
           << "\n (0 ou f)  (fin)               "
           << "\n (1)  controles generaux pour la resolution de l'equilibre generale [c]"
           << "\n (2)  parametres lies au systeme d'equation lineaire "
           << "\n (3)  parametres lies à la dynamique "
           << "\n (4)  parametres lies à l'affichage des resultats [c]" 
           << "\n (5)  parametres lies au contact  " 
           << "\n (6)  parametres lies aux energies  " 
           << "\n (7)  parametres lies aux calculs geometriques sur les elements  " 
           << "\n  ";
        rep = lect_return_defaut(false,"f");
        if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
          break;
        int num = ChangeEntier(rep);
        if (!((num >= 0)&&(num<=7)))
         { cout << "\n Erreur on attendait un entier entre 0 et 7 !!, "
                << "\n redonnez une bonne valeur"
                << "\n ou taper f ou 0 pour arreter le programme"; 
         };
        switch (num)
         { case 0:  // sortie
             { break;} // normalement cela a déjà été filtré avant
           case 1:  // controles generaux pour la resolution de l'equilibre generale
             { sort << "\n\n      controle #------------ "
                    << "\n#--------------------------- "
                    << "\n# PARAMETRE    |  VALEUR   | "
                    << "\n#--------------------------- ";
               Tableau<bool> tab_modif(26,false); // indique qu'est-ce qui a été modifié
               //On va proposer un menu
               string repa=" ";
               cout  << "\n   --- controle generaux ------       ";
               while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
                {try 
                  {  cout << "\n (0 ou f)  (fin)               "
                          << "\n  --- parametres de controle de l'algorithmes et para par defaut "
                          << "\n      [c] -> para tres classique  [-] para assez courants "
                          << "\n (1) frequence de sauvegarde = 1                       [c]     "
                          << "\n (2) type de gestion de sauvegarde = 1   "
                          << "\n (3) FORCE_DELTAT_DU_.INFO       "
                          << "\n (4) coef pas_critique pour deltatmaxi = 0."
                          << "\n (5) coef pas_critique pour deltatmini = -3333256794."
                          << "\n (6) type pas_critique DFC pour deltatmaxi = true "
                          << "\n (7) type pas_critique DFC pour deltatmini = true "
                          << "\n (8) maxi d'iteration pour converger = 100             [-] "
                          << "\n (9) precision de la convergence  = 1.e-3              [-] "
                          << "\n (10) precision sur le temps final = 1.E-12"
                          << "\n (11) type de norme de convergence  = Residu/Reaction  [-]"
                          << "\n      ou: fonction_nD:  <le nom de la fonction nD> "
                          << "\n (12) cinematique sur l'increment  = false"
                          << "\n (13) convergence forcee  = false"
                          << "\n (14) multiplicateur de la charge = 1."
                          << "\n (15) increment de temps  = 1.                         [c]"
                          << "\n (16) temps de fin de calcul = 1.                      [c]"
                          << "\n (17) maximum d'increment de temps = 400               [-]"
                          << "\n (18) increment de redemarage de calcul = 0"
                          << "\n (19) maximum de puissance  = 1.e10"
                          << "\n (20) utilisation du line_search = false"
                          << "\n (21) var_charge_externe  = true"
                          << "\n (22) var_D= false"
                          << "\n (23) ajout au choix sur la norme: "
                          << "\n        et_miniVarDdl et_VarRes et_maxiVarDdl"
                          << "\n (24) delta t maxi    1.                               [c]" 
                          << "\n (25) delta t mini    0.                               [-]"
                          << "\n (26) maximum d'essai d'increment de temps = maxincre  [-]"
                          << "\n ";
                     repa = lect_return_defaut(false,"f");;
                     if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
                        break;
                     int numa = ChangeEntier(repa);
                     if (!((numa >= 0)&&(numa<=26)))
                      { cout << "\n Erreur on attendait un entier entre 0 et 26 !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper f ou 0 pour arreter le programme"; 
                      };
                     int val_int;
                     bool val_bool;
                     double val_double;
                     string val_string,string_inter;
                     bool bonne_lecture = false;

                     switch (numa)
                      { case 0:  // sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 2:
                          { cout << "\n (1) type par intervalle d'increment "
                                 << "\n (2) type par intervalle de temps "
                                 << "\n (3) uniquement l'increment 0 et le dernier increment "
                                 << "\n (4) type par intervalle d'increment + le dernier increment "
                                 << "\n (5) type par intervalle de temps + le dernier increment \n"
                                 ;
                            string type_de_cas_de_sauvegarde;
                            type_de_cas_de_sauvegarde= lect_chaine();
                            cout << " valeur lue :" << type_de_cas_de_sauvegarde;
                            if (type_de_cas_de_sauvegarde == "1") {cas_de_sauvegarde=1;tab_modif(numa)=true;bonne_lecture=true;break;}
                            else if (type_de_cas_de_sauvegarde == "2") {cas_de_sauvegarde=2;tab_modif(numa)=true;bonne_lecture=true;break;}
                            else if (type_de_cas_de_sauvegarde == "3") {cas_de_sauvegarde=3;tab_modif(numa)=true;bonne_lecture=true;break;}
                            else if (type_de_cas_de_sauvegarde == "4") {cas_de_sauvegarde=4;tab_modif(numa)=true;bonne_lecture=true;break;}
                            else if (type_de_cas_de_sauvegarde == "5") {cas_de_sauvegarde=5;tab_modif(numa)=true;bonne_lecture=true;break;}
                            else {cout << "\n valeur lue erronee, on concerve la valeur "<< cas_de_sauvegarde;};
                          }
                        case 1:
                          { cout << "\n nouvelle valeur (un entier ou un reel selon de type d'intervalle) (defaut 1)  ? ";
                            string_inter= lect_return_defaut(false,"1");
                            cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_double = ChangeReel(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 8: case 17: case 18: case 26:
                          { cout << "\n nouvelle valeur (un entier)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_int = ChangeEntier(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 4: case 5: case 9: case 10: case 14: case 15: case 16: case 19: case 24: case 25:
                         { cout << "\n nouvelle valeur (un reel)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_double = ChangeReel(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 3: case 6: case 7: case 12: case 13: case 20: case 21: case 22:
                          { cout << "\n nouvelle valeur (un entier 1(=true) ou 0(=false) )  ? ";
                            val_bool= (bool) lect_double();cout << " valeur lue ="<< val_bool;
                            bonne_lecture=true;
                           break;
                          }
                        case 11: 
                          { cout << "\n nouvelle valeur (un nom)  ? ";
                            int nb_string = 14;
                            Tableau <string > tab_norme(nb_string);
                            tab_norme(1) = "Residu/Reaction_et_Residu";
                            tab_norme(2) = "Residu/Reaction";
                            tab_norme(3) = "Residu/PVExterne";
                            tab_norme(4) = "Residu/PVInterne";
                            tab_norme(5) = "Residu/maxPVI";
                            tab_norme(6) = "Residu";
                            tab_norme(7) = "min(Res,Res/Reaction)";
                            tab_norme(8) = "min(Res,Res/MaX(Reaction_et_PVExterne))";
                            tab_norme(9) = "E_cinetique/E_statique_ET_ResSurReact";
                            tab_norme(10) = "E_cinetique/E_statique_ET_Res/Reac_et_Fext";
                            tab_norme(11) = "E_cinetique";
                            tab_norme(12) = "Bilan_puissance/Max(puiss)";
                            tab_norme(13) = "Residu/Reaction_et_Residu";
                            tab_norme(14) = "fonction_nD:  <un nom de fonction nD> ";
                            int nb_car_maxi=0; // init
                            // on recherche le nombre de caractères maxi
                            for (int i=1;i<nb_string+1;i++)
                              nb_car_maxi = MaX(nb_car_maxi, tab_norme(i).length());
                            // on affiche le menu
                            for (int i=1;i<nb_string+1;i++)
                              cout <<"\n "<< setw(nb_car_maxi) << left << tab_norme(i) <<" ("<<i<<")";
                            cout << "\n ? ";
                            val_string= lect_chaine();cout << " valeur lue ="<< val_string;
                            int num_choix = ChangeEntier(val_string);
                            if ((num_choix == 0) || (Minuscules(val_string) == "f"))
                              break;
                            if ((num_choix > 0)&&(num_choix < nb_string+1))
                                { cout << " norme enregistree: " << tab_norme(num_choix);
                                  norme.nom1 = tab_norme(num_choix);tab_modif(numa)=true;
                                  bonne_lecture=true;break;
                                }
                            else { cout << "\n type incorrect on conserve: " << norme ;};
                            if (norme.nom1 == "fonction_nD:") // on doit demander le nom de la fonction nD
                              {cout << " nom de la fonction nD ? ";
                               norme.nom2= lect_chaine();cout << " valeur lue ="<< norme.nom2;
                              };
                            break;
                          }
                         case 23:
                          { if (norme.nom1 == "fonction_nD:") // si on a déjà enregisté une fonction nD
                             // la suite n'est pas possible
                             {cout << "\n cas d'une norme controlee par une fonction nD, on ne peut pas rajouter d'indication! ";
                             }
                            else
                             {cout << "\n un nom au choix parmi: et_miniVarDdl et_VarRes et_maxiVarDdl ou un blanc  ? ";
                              int nb_string = 3;
                              Tableau <string > tab_norme(nb_string);
                              tab_norme(1) = "et_miniVarDdl";
                              tab_norme(2) = "et_VarRes";
                              tab_norme(3) = "et_maxiVarDdl";
                              int nb_car_maxi=0; // init
                              // on recherche le nombre de caractères maxi
                              for (int i=1;i<nb_string+1;i++)
                                nb_car_maxi = MaX(nb_car_maxi, tab_norme(i).length());
                              // on affiche le menu
                              for (int i=1;i<nb_string+1;i++)
                                cout <<"\n "<< setw(nb_car_maxi) << left << tab_norme(i) <<" ("<<i<<")";
                              cout << "\n ? ";
                              val_string= lect_chaine();cout << " valeur lue ="<< val_string;
                              int num_choix = ChangeEntier(val_string);
                              if ((num_choix == 0) || (Minuscules(val_string) == "f"))
                                break;
                              if ((num_choix > 0)&&(num_choix < nb_string+1))
                                  { norme.nom1 += val_string;tab_modif(numa)=true;
                                    cout << " norme enregistree: " << norme;
                                    bonne_lecture=true;
                                    break;
                                  }
                              else { cout << "\n type incorrect on conserve: " << norme ;};
                             };
                            break;
                          }
                        
                      };
                     if (bonne_lecture)
                      switch (numa)
                        { case 0:  // préparation de sortie
                            { break;} // normalement cela a déjà été filtré avant
                          case 1: { sauvegarde = val_double;tab_modif(numa)=true;break;}
                          case 3: { force_deltat = val_bool;tab_modif(numa)=true;break;}
                          case 4: { coef_pas_critique_deltatmaxi = val_double;tab_modif(numa)=true;break;}
                          case 5: { coef_pas_critique_deltatmini = val_double;tab_modif(numa)=true;break;}
                          case 6: { typeDFC_pas_critique_deltatmaxi = val_bool;tab_modif(numa)=true;break;}
                          case 7: { typeDFC_pas_critique_deltatmini = val_bool;tab_modif(numa)=true;break;}
                          case 8: { iterations = val_int;tab_modif(numa)=true;break;}
                          case 9: { precision = val_double;tab_modif(numa)=true;break;}
                          case 10: { tempo_specifique_algo.prectemps = val_double;tab_modif(numa)=true;break;}
                          case 12: { cinematique = val_bool;tab_modif(numa)=true;break;}
                          case 13: { conv_forcee = val_bool;tab_modif(numa)=true;break;}
                          case 14: { multiplicateur = val_double;tab_modif(numa)=true;break;}
                          case 15: { tempo_specifique_algo.deltat = val_double;tab_modif(numa)=true;break;}
                          case 16: { tempo_specifique_algo.tempsfin = val_double;tab_modif(numa)=true;break;}
                          case 17: { maxincre = val_int;tab_modif(numa)=true;break;}
                          case 18: { restart = val_int;tab_modif(numa)=true;break;}
                          case 19: { max_puissance = val_double;tab_modif(numa)=true;break;}
                          case 20: { line_search = val_bool;tab_modif(numa)=true;break;}
                          case 21: { var_charge_externe = val_bool;tab_modif(numa)=true;break;}
                          case 22: { var_D = val_bool;tab_modif(numa)=true;break;}
                          case 24: { tempo_specifique_algo.deltatmaxi = val_double;tab_modif(numa)=true;break;}
                          case 25: { tempo_specifique_algo.deltatmini = val_double;tab_modif(numa)=true;break;}
                          case 26: { max_essai_incre = val_int;tab_modif(numa)=true;break;}
                        };

                  }    
                 catch (ErrSortieFinale)
                      // cas d'une direction voulue vers la sortie
                      // on relance l'interuption pour le niveau supérieur
                    { ErrSortieFinale toto;
                      throw (toto);
                    }
                 catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
                  {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour sortir "; 
                  };
                }; //-- fin du while interne
               // écriture des paramètres de contrôle
               for (int i=1;i<=26;i++)
                  if (tab_modif(i))
                   {switch (i)
                      { case 1: { sort << "\n SAUVEGARDE ";
                                  switch (cas_de_sauvegarde)
                                    {case 2: sort << " INTER_TEMPS     " << sauvegarde ;break;
                                     case 3: sort << " DERNIER_CALCUL  ";break;
                                     case 4: sort << " INTER_INCREMENT " << sauvegarde << " DERNIER_CALCUL ";break;
                                     case 5: sort << " INTER_TEMPS     " << sauvegarde << " DERNIER_CALCUL ";break;
                                     default: sort << sauvegarde;
                                    };
                                  break;}
                        case 3: { sort <<  "\n FORCE_DELTAT_DU_.INFO "<< force_deltat;break;}
                        case 8: { sort <<  "\n ITERATIONS  " << iterations ;break;}
                        case 9: { sort <<  "\n PRECISION   "<< precision ;break;}
                        case 10: { sort << "\n PRECTEMPS   " << tempo_specifique_algo.prectemps;break;}
                        case 11: { sort << "\n NORME       " << norme;break;}
                        case 12: { sort << "\n CINEMATIQUE " << cinematique;break;}
                        case 13: { sort << "\n CONV_FORCEE " << conv_forcee;break;}
                        case 14: { sort << "\n MULTIPLICATEUR " << multiplicateur;break;}
                        case 15: { sort << "\n DELTAt      " << tempo_specifique_algo.deltat;break;}
                        case 16: { sort << "\n TEMPSFIN    " << tempo_specifique_algo.tempsfin;break;}
                        case 17: { sort << "\n MAXINCRE    " << maxincre ;break;}
                        case 18: { sort << "\n RESTART     " << restart;break;}
                        case 19: { sort << "\n MAX_PUISSANCE " << max_puissance;break;}
                        case 20: { sort << "\n LINE_SEARCH " << line_search;break;}
                        case 21: { sort << "\n VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR " << var_charge_externe;break;}
                        case 22: { sort << "\n VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR " << var_D;break;}
                        case 24: { sort << "\n DELTAtMAXI  " << tempo_specifique_algo.deltatmaxi;break;}
                        case 25: { sort << "\n DELTAtMINI  " << tempo_specifique_algo.deltatmini;break;}
                        case 26: { sort << "\n MAX_ESSAI_INCRE " << max_essai_incre ;break;}
                      };
                   };
                  
               // cas du pas de temps maxi
               if (tab_modif(4) || tab_modif(6)) // ou car si l'on change un des deux cela veut dire un facteur du coef critique
                {if (typeDFC_pas_critique_deltatmaxi)
                  {sort << "\n DELTAtMAXI COEF_PASCRITIQUE_DFC "<< coef_pas_critique_deltatmaxi ;}
                 else
                  {sort << "\n DELTAtMAXI COEF_PASCRITIQUE "<< coef_pas_critique_deltatmaxi ;};
                };
               if (tab_modif(5) || tab_modif(7))
                {if (typeDFC_pas_critique_deltatmini)
                  {sort << "\n DELTAtMINI COEF_PASCRITIQUE_DFC "<< coef_pas_critique_deltatmini ;}
                 else
                  {sort << "\n DELTAtMINI COEF_PASCRITIQUE "<< coef_pas_critique_deltatmini ;};
                };
               break;
             }
           case 2:  // parametres lies au systeme d'equation lineaire
             { sort << "\n\n      para_syteme_lineaire #------------ "
                    << "\n#--------------------------- "
                    << "\n# PARAMETRE    |  VALEUR   | "
                    << "\n#--------------------------- ";
               int nb_item = 8; // nombre d'item du menu
               Tableau<bool> tab_modif(nb_item,false); // indique qu'est-ce qui a été modifié
               //On va proposer un menu
               string repa=" ";
               cout  << "\n   --- parametre de la resolution du systeme lineaire global ------       ";
               while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
                {try
                  {  cout << "\n (0 ou f)  (fin)               "
                          << "\n  --- parametres de controle  et para par defaut "
                          << "\n      [c] -> para tres classique  [-] para assez courants "
                          << "\n (1) TYPE_MATRICE = BANDE_SYMETRIQUE  "
                          << "\n (2) SYMETRIE_MATRICE = 1   "
                          << "\n (3) TYPE_RESOLUTION = CHOLESKY      "
                          << "\n (4) TYPE_PRECONDITIONNEMENT = DIAGONAL "
                          << "\n (5) NB_ITER_NONDIRECTE = 30"
                          << "\n (6) TOLERANCE = 1.e-7 "
                          << "\n (7) NB_VECT_RESTART = 32 "
                          << "\n (8) OPTIMISATION_POINTEURS_ASSEMBLAGE  = 0  [-] "
                          << "\n NB: pour les matrices secondaires: voir doc. \n";
                     repa = lect_return_defaut(false,"f");
                     if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
                        break;
                     int numa = ChangeEntier(repa);
                     if (!((numa >= 0)&&(numa<=nb_item)))
                      { cout << "\n Erreur on attendait un entier entre 0 et "<<nb_item<<" !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper f ou 0 pour arreter le programme";
                      };
                     int val_int;
                     bool val_bool;
                     double val_double;
                     string val_string,string_inter;
                     bool bonne_lecture = false;

                     switch (numa)
                      { case 0:  // sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 1:
                          { cout << "\n nouveau type de matrice (un nom cf. doc )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (Existe_Enum_matrice(string_inter))
                              { val_string = string_inter;bonne_lecture=true;}
                            else
                              { cout << " *** erreur: ce type de matrice n'est pas correcte !! ";};
                           break;
                          }
                        case 2:
                          { cout << "\n symetrie de la matrice (1 ou 0 )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { int essai  = ChangeEntier(string_inter);
                                 if ((essai == 1) || (essai == 0))
                                  {val_int = essai;bonne_lecture=true;}
                                 else
                                  { cout << " ** erreur il faut 1 ou 0 ! "; };
                               }
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 3:
                          { cout << "\n type de resolution (un nom cf. doc )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (Existe_Enum_type_resolution_matri(string_inter))
                              { val_string = string_inter;bonne_lecture=true;}
                            else
                              { cout << " *** erreur: ce type de resolution n'est pas correcte !! ";};
                           break;
                          }
                        case 4:
                          { cout << "\n type de preconditionnement (un nom cf. doc )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (Existe_Enum_preconditionnement(string_inter))
                              { val_string = string_inter;bonne_lecture=true;}
                            else
                              { cout << " *** erreur: ce type de preconditionnement n'est pas correcte !! ";};
                           break;
                          }
                        case 5:
                          { cout << "\n nb iteration pour un methode iterative (un entier)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { val_int = ChangeEntier(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 6:
                          { cout << "\n precision de convergence pour un methode iterative (un reel)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { val_double = ChangeReel(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 7:
                          { cout << "\n nb vecteurs sauvegarde pour un methode iterative (un entier)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { val_int = ChangeEntier(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 8:
                          { cout << "\n optimisation des pointeurs d'assemblage (1 ou 0)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { val_int = ChangeEntier(string_inter);bonne_lecture=true;}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        
                      };
                     if (bonne_lecture)
                      switch (numa)
                        { case 0:  // préparation de sortie
                            { break;} // normalement cela a déjà été filtré avant
                          case 1: { type_matrice = Id_nom_matrice(val_string);tab_modif(numa)=true;break;}
                          case 2: { symetrie_matrice = val_int;tab_modif(numa)=true;break;}
                          case 3: { type_resolution = Id_nom_resolution(val_string);tab_modif(numa)=true;break;}
                          case 4: { type_preconditionnement = Id_nom_preconditionnement(val_string);tab_modif(numa)=true;break;}
                          case 5: { nb_iter_nondirecte = val_int;tab_modif(numa)=true;break;}
                          case 6: { tolerance = val_double;tab_modif(numa)=true;break;}
                          case 7: { nb_vect_restart = val_int;tab_modif(numa)=true;break;}
                          case 8: { opti_pointeur_assemblage = val_int;tab_modif(numa)=true;break;}
                       };
                   }
                 catch (ErrSortieFinale)
                      // cas d'une direction voulue vers la sortie
                      // on relance l'interuption pour le niveau supérieur
                    { ErrSortieFinale toto;
                      throw (toto);
                    }
                 catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
                  {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour sortir ";
                  };
                }; //-- fin du while interne
               // écriture des paramètres de contrôle
               for (int i=1;i<=nb_item;i++)
                  if (tab_modif(i))
                   {switch (i)
                      { case 1: { sort << "\n TYPE_MATRICE " << Nom_matrice(type_matrice);break;}
                        case 2: { sort << "\n SYMETRIE_MATRICE " << symetrie_matrice;break;}
                        case 3: { sort <<  "\n TYPE_RESOLUTION "<< Nom_resolution(type_resolution);break;}
                        case 4: { sort <<  "\n TYPE_PRECONDITIONNEMENT  " << Nom_preconditionnement(type_preconditionnement) ;break;}
                        case 5: { sort <<  "\n NB_ITER_NONDIRECTE   "<< nb_iter_nondirecte ;break;}
                        case 6: { sort << "\n TOLERANCE   " << tolerance;break;}
                        case 7: { sort << "\n NB_VECT_RESTART       " << nb_vect_restart;break;}
                        case 8: { sort << "\n OPTIMISATION_POINTEURS_ASSEMBLAGE " << opti_pointeur_assemblage;break;}
                     };
                   };
              
               break;
             }
           case 3:  // parametres lies à la dynamique
             {                break;
              }
           case 4:  // parametres lies à l'affichage des resultats
             { sort << "\n\n      para_affichage #------------ "
                    << "\n#--------------------------- "
                    << "\n# PARAMETRE    |  VALEUR   | "
                    << "\n#--------------------------- ";
               int nb_choix = 7; // nombre de choix
               Tableau<bool> tab_modif(nb_choix,false); // indique qu'est-ce qui a été modifié
               //On va proposer un menu
               string repa=" ";
               cout  << "\n   --- affichage ------       ";
               while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
                {try 
                  {  cout << "\n (0 ou f)  (fin)               "
                          << "\n  --- parametres de controle de l'algorithmes et para par defaut "
                          << "\n      [c] -> para tres classique  [-] para assez courants "
                          << "\n (1) frequence d'affichage sur les increment = 1          [-]"
                          << "\n     (FREQUENCE_AFFICHAGE_INCREMENT) "
                          << "\n (2) frequence d'affichage sur les iteration = 1          [-]"
                          << "\n     (FREQUENCE_AFFICHAGE_ITERATION) "
                          << "\n (3) frequence de la sortie au fil du calcul = -1000000  [c]"
                          << "\n     (FREQUENCE_SORTIE_FIL_DU_CALCUL) "
                          << "\n (4) cas de_sortie_fil_calcul"
                          << "\n     (FREQUENCE_AFFICHAGE_INCREMENT) "
                          << "\n (5) NB chiffre significatifs pour archive et ecran = 17  "
                          << "\n     (NB_CHIFFRE_POUR_DOUBLE_CALCUL) "
                          << "\n (6) NB chiffre significatifs pour graphique  = 12  "
                          << "\n     (NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE) "
                          << "\n (7) NB chiffre significatifs pour ecran  = 8  "
                          << "\n     (NB_CHIFFRE_POUR_DOUBLE_ECRAN) "
                         << "\n ";
                     repa = lect_return_defaut(false,"f");
                     if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
                        break;
                     int numa = ChangeEntier(repa);
                     if (!((numa >= 0)&&(numa<=nb_choix)))
                      { cout << "\n Erreur on attendait un entier entre 0 et "<<nb_choix<<" !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper f ou 0 pour arreter le programme"; 
                      };
                     int val_int;
                     bool val_bool;
                     double val_double;
                     string val_string,string_inter;

                     switch (numa)
                      { case 0:  // sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 4:
                          { cout << "\n (1) type par intervalle d'increment "
                                 << "\n (2) type par intervalle de temps "
                                 << "\n (3) uniquement le dernier increment \n";
                            string type_de_cas_de_sortie_fil_calcul;
                            type_de_cas_de_sortie_fil_calcul= lect_chaine();
                            cout << " valeur lue :" << type_de_cas_de_sortie_fil_calcul;
                            if (type_de_cas_de_sortie_fil_calcul == "1")
                              {cas_de_sortie_fil_calcul=1;tab_modif(numa)=true;break;}
                            else if (type_de_cas_de_sortie_fil_calcul == "2")
                              {cas_de_sortie_fil_calcul=2;tab_modif(numa)=true;break;}
                            else if (type_de_cas_de_sortie_fil_calcul == "3")
                              {cas_de_sortie_fil_calcul=3;tab_modif(numa)=true;break;}
                            else
                              {cout << "\n valeur lue erronee, on concerve la valeur "<< cas_de_sortie_fil_calcul;};
                          }
                        case 1: case 2: case 5: case 6: case 7:
                          { cout << "\n nouvelle valeur (un entier)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_int = ChangeEntier(string_inter);}
                            else
                              { cout << " erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 3: 
                          { cout << "\n nouvelle valeur (un reel)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_double = ChangeReel(string_inter);}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                      };
                     switch (numa)
                      { case 0:  // préparation de sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 1: { frequence_affichage_increment = val_int;tab_modif(numa)=true;break;}
                        case 2: { frequence_affichage_iteration = val_int;tab_modif(numa)=true;break;}
                        case 3: { sortie_fil_calcul = val_double;tab_modif(numa)=true;break;}
                        case 5: { nb_diggit_double_calcul = val_int;tab_modif(numa)=true;break;}
                        case 6: { nb_diggit_double_graphique = val_int;tab_modif(numa)=true;break;}
                        case 7: { nb_diggit_double_ecran = val_int;tab_modif(numa)=true;break;}
                      };
                    // écriture

                  }    
                 catch (ErrSortieFinale)
                      // cas d'une direction voulue vers la sortie
                      // on relance l'interuption pour le niveau supérieur
                    { ErrSortieFinale toto;
                      throw (toto);
                    }
                 catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
                  {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour sortir "; 
                  };
                }; //-- fin du while interne
               // écriture des paramètres de contrôle
               for (int i=1;i<=nb_choix;i++)
                  if (tab_modif(i))
                   {switch (i)
                      { case 3: case 4 :
                         { sort << "\n FREQUENCE_SORTIE_FIL_DU_CALCUL ";
                           switch (cas_de_sortie_fil_calcul)
                                {case 2: sort << " INTER_TEMPS " << sortie_fil_calcul ;break;
                                 case 3: sort << " DERNIER_CALCUL ";break;
                                 default: sort << sortie_fil_calcul;
                                };
                           break;
                         }
                        case 1: { sort << "\n FREQUENCE_AFFICHAGE_INCREMENT "<< frequence_affichage_increment;break;}
                        case 2: { sort << "\n FREQUENCE_AFFICHAGE_ITERATION " << frequence_affichage_iteration ;break;}
                        case 5: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_CALCUL "<< nb_diggit_double_calcul ;break;}
                        case 6: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE " << nb_diggit_double_graphique;break;}
                        case 7: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_ECRAN " << nb_diggit_double_ecran;break;}
                      };
                   };
               break;
             }
           case 5:  // parametres lies au contact
             { sort << "\n\n      para_contact #------------ "
                    << "\n#--------------------------- "
                    << "\n# PARAMETRE    |  VALEUR   | "
                    << "\n#--------------------------- ";
               Tableau<bool> tab_modif(36,false); // indique qu'est-ce qui a été modifié
               //On va proposer un menu
               string repa=" ";
               cout  << "\n   --- controle generaux ------       ";
               while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
                {try 
                  {  cout << "\n (0 ou f)  (fin)               "
                          << "\n  --- parametres de controle du contact "
                          << "\n      [c] -> para tres classique  [-] para assez courants "
                          << "\n (1) PRECISION_POINT_INTERNE_DEBUT = 1.e-6            "
                          << "\n (2) FACT_POUR_RAYON_ACCOSTAGE = 1.   "
                          << "\n (3) DISTANCE_MAXI_AU_PT_PROJETE = tres grand      "
                          << "\n (4) PRECISION_BOITE_PRELOCALISATION = 1.05 "
                          << "\n (5) MINI_EXTRA_BOITE_PRELOCALISATION = -0.001 "
                          << "\n (6) CONTACT_TYPE = 0 "
                          << "\n (7) PENALISATION_PENETRATION = 0.1 "
                          << "\n (8) TYPE_PENALISATION_PENETRATION = 2  "
                          << "\n (9) PENETRATION_CONTACT_MAXI  = 0.1   "
                          << "\n (10) PENETRATION_BORNE_REGULARISATION = tres grand "
                          << "\n (11) FORCE_CONTACT_NOEUD_MAXI  = tres grand "
                          << "\n (12) PENALISATION_TANGENTIELLE  = 1.e6 "
                          << "\n (13) PRECISION_PT_SUR_FRONTIERE  = 1.e-4 "
                          << "\n (14) NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE = 10 "
                          << "\n (15) NB_DECOLLEMENT_MAXI  = 1    "
                          << "\n (16) TYPE_DE_DECOLLEMENT = 0    "
                          << "\n (17) NB_MOY_GLISSANT = 1  "
                          << "\n (18) NIVEAU_COMMENTAIRE_LESCONTACTS = 0 "
                          << "\n (19) NIVEAU_COMMENTAIRE_CONTACT = 0 "
                          << "\n (20) TYPE_PENALISATION_TANGENTIELLE = 2  "
                          << "\n (21) TANGENTIELLE_CONTACT_MAXI  = 0.1   "
                          << "\n (22) TANGENTIELLE_BORNE_REGULARISATION = tres grand "
                          << "\n (23) FORCE_TANGENTIELLE_NOEUD_MAXI  = tres grand "
                          << "\n (24) AJOUT_EXTRA_BOITE_PRELOCALISATION = 0. "
                          << "\n (25) OPTIMISATION_NUMEROTATION = 0 "
                          << "\n (26) FCT_ND_BASCUL_CONTACT_TYPE_4 = '_' "
                          << "\n (27) FCT_ND_PENALISATION_PENETRATION  "
                          << "\n (28) FCT_ND_PENETRATION_CONTACT_MAXI  "
                          << "\n (29) FCT_ND_PENETRATION_BORNE_REGULARISATION "
                          << "\n (30) FCT_ND_FORCE_CONTACT_NOEUD_MAXI "
                          << "\n (31) FCT_ND_PENALISATION_TANGENTIELLE "
                          << "\n (32) FCT_ND_TANGENTIELLE_CONTACT_MAXI "
                          << "\n (33) FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "
                          << "\n (34) FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "
                          << "\n (35) FCT_ND_NIVEAU_COMMENTAIRE_CONTACT "
                          << "\n (36 ou h ou ? ) informations             "
                          << "\n ";
                     repa = lect_return_defaut(false,"f");
                     if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
                        break;
                     int numa = ChangeEntier(repa);
                     if (repa == "?") numa = 36;

                     if (!((numa >= 0)&&(numa<=36)))
                      { cout << "\n Erreur on attendait un entier entre 0 et 36 !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper f ou 0 pour arreter le programme"; 
                      };
                     int val_int;
                     bool val_bool;
                     double val_double;
                     string val_string,string_inter;

                     switch (numa)
                      { case 0:  // sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 6: case 8: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 25:
                          { cout << "\n nouvelle valeur (un entier )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_int = ChangeEntier(string_inter);}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 1: case 2: case 3: case 4: case 5:  case 7: case 9: case 10: case 11:
                        case 12: case 13: case 21: case 22: case 23: case 24:
                         { cout << "\n nouvelle valeur (un reel)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_double = ChangeReel(string_inter);}
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 26:case 27:case 28:case 29:case 30:case 31:case 32:case 33:case 34:case 35:
                         { cout << "\n donner le nom de la fonction nD  (un string )  ? ";
                           val_string= lect_chaine();cout << " nom lue ="<<val_string;
                           break;
                          }

                        case 36:
                           { cout <<  "\n PRECISION_POINT_INTERNE_DEBUT:  precision du test: point interieur ?, "
                                  <<  " avant le debut des calculs "
	                                 <<  "\n FACT_POUR_RAYON_ACCOSTAGE: facteur multiplicatif du deplacement maxi entre t et tdt"
                                  <<  "  donnant la  distance maxi admissible entre le point et le point projete "
                                  <<  "\n DISTANCE_MAXI_AU_PT_PROJETE: a priori grand, est ensuite eventuellement "
                                  <<  " gere par l'entree des donnees"
                                  <<  "\n PRECISION_BOITE_PRELOCALISATION: donne la proportion de plus qui est "
                                  <<  " attribuee aux boites de prelocalisation "
                                  <<  "\n MINI_EXTRA_BOITE_PRELOCALISATION: permet le calcul de la bande mini autour de la boite de prelocalisation "
                                  <<  "\n AJOUT_EXTRA_BOITE_PRELOCALISATION: ajout dans toutes les directions autour de la boite de prelocalisation "
                                  <<  "\n CONTACT_TYPE: a priori il n'y a pas de contact  d'element "
                                  <<  "\n PENALISATION_PENETRATION: facteur pour le calcul du coefficient de penalisation "
                                  <<  "\n TYPE_PENALISATION_PENETRATION: par defaut le calcul est identique a ls-dyna avec "
                                  <<  "  la compressibilite du maitre "
                                  <<  "\n PENETRATION_CONTACT_MAXI: cf doc "
                                  <<  "\n PENETRATION_BORNE_REGULARISATION: cf doc "
                                  <<  "\n FORCE_CONTACT_NOEUD_MAXI: borne maxi pour la force de reaction du noeud "
                                  <<  "\n PENALISATION_TANGENTIELLE: facteur de penalisation pour le deplacement tangentiel "
                                  <<  "\n PRECISION_PT_SUR_FRONTIERE: precision de positionnement sur les X^ar d'un pt "
                                  <<  "  en contact sur une frontiere "
                                  <<  "\n NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE: nb de boucle maxi pour la recherche du "
                                  <<  " positionnement du pt en contact "
                                  <<  "\n NB_DECOLLEMENT_MAXI: nb de fois qu'un noeud decolle pour n'etre plus considere en contact "
                                  <<  "\n TYPE_DE_DECOLLEMENT: cf doc "
                                  <<  "\n NB_MOY_GLISSANT: nb de pt utilise pour la  moyenne glissante cf doc "
                                  <<  "\n NIVEAU_COMMENTAIRE_CONTACT: si sup au niveau global, gere les sorties de commentaires "
                                  <<  "\n pour la penalisation sur le deplacement tangentiel, meme logique que la "
                                  <<  "\n penalisation en penetration "
                                  <<  "\n OPTIMISATION_NUMEROTATION : si diff de 0, indique une renumerotation en fct"
                                  <<  "\n du contact, en particulier apres l'apparition ou la disparition "
                                  <<  "\n d'element de contact"
                                  <<  "\n FCT_ND_BASCUL_CONTACT_TYPE_4: nom d'une fonction nD permettant de piloter "
                                  <<  "\n le basculement du type de contact 4 a 2 (cf. doc) "
                                  << endl;
                             break;
                           }
                        default:
                           cout << "\n cas non prevu, recommencer ! ";
                      };
                     switch (numa)
                      { case 0:  // préparation de sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 1: { prec_pt_int_deb = val_double;tab_modif(numa)=true;break;}
                        case 2: { factPourRayonAccostage = val_double;tab_modif(numa)=true;break;}
                        case 3: { distanceMaxiAuPtProjete = val_double;tab_modif(numa)=true;break;}
                        case 4: { extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
                        case 5: { mini_extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
                        case 6: { contact_type = val_int;tab_modif(numa)=true;break;}
                        case 7: { penalisationPenetration = val_double;tab_modif(numa)=true;break;}
                        case 8: { typePenalisationPenetration = val_int;tab_modif(numa)=true;break;}
                        case 9: { penetration_contact_maxi = val_double;tab_modif(numa)=true;break;}
                        case 10: { penetration_borne_regularisation = val_double;tab_modif(numa)=true;break;}
                        case 11: { force_contact_noeud_maxi = val_double;tab_modif(numa)=true;break;}
                        case 12: { penalisationTangentielle = val_double;tab_modif(numa)=true;break;}
                        case 13: { prec_pt_sur_frontiere = val_double;tab_modif(numa)=true;break;}
                        case 14: { nb_boucle_newton_position_frontiere = val_int;tab_modif(numa)=true;break;}
                        case 15: { nbDecolAutorise = val_int;tab_modif(numa)=true;break;}
                        case 16: { typeDeDecolement = val_int;tab_modif(numa)=true;break;}
                        case 17: { nb_glissant = val_int;tab_modif(numa)=true;break;}
                        case 18: { niveau_commentaire_lescontacts = val_int;tab_modif(numa)=true;break;}
                        case 19: { niveau_commentaire_contact = val_int;tab_modif(numa)=true;break;}
                        case 20: { typePenalisationTangentielle = val_int;tab_modif(numa)=true;break;}
                        case 21: { tangentielle_contact_maxi = val_double;tab_modif(numa)=true;break;}
                        case 22: { tangentielle_borne_regularisation = val_double;tab_modif(numa)=true;break;}
                        case 23: { force_tangentielle_noeud_maxi = val_double;tab_modif(numa)=true;break;}
                        case 24: { ajout_extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
                        case 25: { optimisation_numerotation = val_int;tab_modif(numa)=true;break;}
                        case 26: { fct_nD_bascul_contact_type_4 = val_string;tab_modif(numa)=true;break;}
                        case 27: { fct_nD_penalisationPenetration = val_string;tab_modif(numa)=true;break;}
                        case 28: { fct_nD_penetration_contact_maxi = val_string;tab_modif(numa)=true;break;}
                        case 29: { fct_nD_penetration_borne_regularisation = val_string;tab_modif(numa)=true;break;}
                        case 30: { fct_nD_force_contact_noeud_maxi = val_string;tab_modif(numa)=true;break;}
                        case 31: { fct_nD_penalisationTangentielle = val_string;tab_modif(numa)=true;break;}
                        case 32: { fct_nD_tangentielle_contact_maxi = val_string;tab_modif(numa)=true;break;}
                        case 33: { fct_nD_tangentielle_borne_regularisation = val_string;tab_modif(numa)=true;break;}
                        case 34: { fct_nD_force_tangentielle_noeud_maxi = val_string;tab_modif(numa)=true;break;}
                        case 35: { fct_niveau_commentaire_contact = val_string;tab_modif(numa)=true;break;}
                        default: break;
                      };
                    // écriture

                  }    
                 catch (ErrSortieFinale)
                      // cas d'une direction voulue vers la sortie
                      // on relance l'interuption pour le niveau supérieur
                    { ErrSortieFinale toto;
                      throw (toto);
                    }
                 catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
                  {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour sortir "; 
                  };
                }; //-- fin du while interne
               // écriture des paramètres de contrôle
               for (int i=1;i<=35;i++)
                  if (tab_modif(i))
                   {switch (i)
                      { case 1: { sort << "\n PRECISION_POINT_INTERNE_DEBUT "<< prec_pt_int_deb;break;}
                        case 2: { sort << "\n FACT_POUR_RAYON_ACCOSTAGE "<< factPourRayonAccostage;break;}
                        case 3: { sort << "\n DISTANCE_MAXI_AU_PT_PROJETE "<< distanceMaxiAuPtProjete;break;}
                        case 4: { sort << "\n PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation ;break;}
                        case 5: { sort << "\n MINI_EXTRA_BOITE_PRELOCALISATION "<< mini_extra_boite_prelocalisation ;break;}
                        case 6: { sort << "\n CONTACT_TYPE " << contact_type;break;}
                        case 7: { sort << "\n PENALISATION_PENETRATION " << penalisationPenetration;break;}
                        case 8: { sort << "\n TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration;break;}
                        case 9: { sort << "\n PENETRATION_CONTACT_MAXI " << penetration_contact_maxi;break;}
                        case 10: { sort << "\n PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation;break;}
                        case 11: { sort << "\n FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi;break;}
                        case 12: { sort << "\n PENALISATION_TANGENTIELLE " << penalisationTangentielle ;break;}
                        case 13: { sort << "\n PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere;break;}
                        case 14: { sort << "\n NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere;break;}
                        case 15: { sort << "\n NB_DECOLLEMENT_MAXI " << nbDecolAutorise;break;}
                        case 16: { sort << "\n TYPE_DE_DECOLLEMENT " << typeDeDecolement;break;}
                        case 17: { sort << "\n NB_MOY_GLISSANT " << nb_glissant;break;}
                        case 18: { sort << "\n NIVEAU_COMMENTAIRE_LESCONTACTS " << niveau_commentaire_lescontacts;break;}
                        case 19: { sort << "\n NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact;break;}
                        case 20: { sort << "\n TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle;break;}
                        case 21: { sort << "\n TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi;break;}
                        case 22: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation;break;}
                        case 23: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi;break;}
                        case 24: { sort << "\n AJOUT_EXTRA_BOITE_PRELOCALISATION "<< ajout_extra_boite_prelocalisation ;break;}
                        case 25: { sort << "\n OPTIMISATION_NUMEROTATION "<< optimisation_numerotation ;break;}
                        case 26: { sort << "\n FCT_ND_BASCUL_CONTACT_TYPE_4 "<< fct_nD_bascul_contact_type_4 ;break;}
                        case 27: { sort << "\n PENALISATION_PENETRATION FCT_ND_PENALISATION_PENETRATION "<< fct_nD_penalisationPenetration ;break;}
                        case 28: { sort << "\n PENETRATION_CONTACT_MAXI FCT_ND_PENETRATION_CONTACT_MAXI "<< fct_nD_penetration_contact_maxi ;break;}
                        case 29: { sort << "\n PENETRATION_BORNE_REGULARISATION FCT_ND_PENETRATION_BORNE_REGULARISATION "<< fct_nD_penetration_borne_regularisation ;break;}
                        case 30: { sort << "\n FORCE_CONTACT_NOEUD_MAXI FCT_ND_FORCE_CONTACT_NOEUD_MAXI "<< fct_nD_force_contact_noeud_maxi ;break;}
                        case 31: { sort << "\n PENALISATION_TANGENTIELLE FCT_ND_PENALISATION_TANGENTIELLE "<< fct_nD_penalisationTangentielle ;break;}
                        case 32: { sort << "\n TANGENTIELLE_CONTACT_MAXI FCT_ND_TANGENTIELLE_CONTACT_MAXI "<< fct_nD_tangentielle_contact_maxi ;break;}
                        case 33: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "<< fct_nD_tangentielle_borne_regularisation ;break;}
                        case 34: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "<< fct_nD_force_tangentielle_noeud_maxi ;break;}
                        case 35: { sort << "\n NIVEAU_COMMENTAIRE_CONTACT FCT_ND_NIVEAU_COMMENTAIRE_CONTACT "<< fct_niveau_commentaire_contact ;break;}
                        default: break;
                      };
                   };
               break;
             }
           case 6:  // parametres lies aux energies
             {                break;
              }
           case 7:  // parametres lies aux calculs geometriques sur les elements
             { sort << "\n\n      para_calculs_geometriques #------------ "
                    << "\n#--------------------------- "
                    << "\n# PARAMETRE    |  VALEUR   | "
                    << "\n#--------------------------- ";
               int nb_choix = 7; // nombre de choix
               Tableau<bool> tab_modif(nb_choix,false); // indique qu'est-ce qui a été modifié
               //On va proposer un menu
               string repa=" ";
               cout  << "\n   --- affichage ------       ";
               while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
                {try
                  {  cout << "\n (0 ou f)  (fin)               "
                          << "\n  --- parametres lies aux calculs geometriques sur les elements et para par defaut "
                          << "\n      [c] -> para tres classique  [-] para assez courants "
                          << "\n (1) precision sur theta_i pour test in/out element = 1.e-4     "
                          << "\n     (POINT_INTERNE_DELTA_THETAI_MAXI) "
                          << "\n (2) precision sur theta_i pour test si in/sur frontiere/out element = 1.e-6 "
                          << "\n     (POINT_INTERNE_PREC_THETAI_INTERNE) "
                          << "\n (3) nb de boucle de Newton pour recherche des theta_i pour surface non lineaire = 10 "
                          << "\n     (POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI) "
                          << "\n (4) nb de fois le pt est externe dans boucle de Newton (3) avant que "
                          << "\n     declare definitivement externe -> arret boucle : = 3 "
                          << "\n     (POINT_INTERNE_NB_EXTERNE) "
                          << "\n (5) indique si oui non -> calcul des volumes entre la membrane et les plans de ref (= 0)  "
                          << "\n     (CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF) "
                          << "\n (6) rapport maxi entre jacobien de la facette centrale et du pti en epaisseur "
                          << "\n     pour les elements coques = 200. "
                          << "\n     (RATIO_MAXI_JACOMEMBRANE_JACOPTI) "
                          << "\n (7) methode pour inversion du tenseur metrique (CRAMER ou LU_EQUILIBRE)  = CRAMER  "
                          << "\n     (TYPE_CALNUM_INVERSION_METRIQUE) "
                         << "\n ";
                     repa = lect_return_defaut(false,"f");
                     if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
                        break;
                     int numa = ChangeEntier(repa);
                     if (!((numa >= 0)&&(numa<=nb_choix)))
                      { cout << "\n Erreur on attendait un entier entre 0 et "<<nb_choix<<" !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper f ou 0 pour arreter le programme";
                      };
                     int val_int;
                     bool val_bool;
                     double val_double;
                     string val_string,string_inter;
                     bool bonne_lecture = false;

                     switch (numa)
                      { case 0:  // sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 3: case 4:
                          { cout << "\n nouvelle valeur (un entier)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est numérique
                            if (isNumeric( string_inter.c_str(), 10))
                              { val_int = ChangeEntier(string_inter);bonne_lecture=true;}
                            else
                              { cout << " erreur: valeur non numerique !! ";};
                           break;
                          }
                        case 1: case 2: case 6:
                          { cout << "\n nouvelle valeur (un reel)  ? ";
                             string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                             // on test si c'est numérique
                             if (isNumeric( string_inter.c_str(), 10))
                               { val_double = ChangeReel(string_inter);bonne_lecture=true;}
                             else
                               { cout << " *** erreur: valeur non numerique !! ";};
                            break;
                           }
                        case 5:
                          { cout << "\n calcul des volumes (1 ou 0 )  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (isNumeric( string_inter.c_str(), 10))
                               { int essai  = ChangeEntier(string_inter);
                                 if ((essai == 1) || (essai == 0))
                                  {val_int = essai;bonne_lecture=true;}
                                 else
                                  { cout << " ** erreur il faut 1 ou 0 ! "; };
                               }
                            else
                              { cout << " *** erreur: valeur non numerique !! ";};
                           break;
                          }
                         case 7:
                          { cout << "\n methode d'inversion (CRAMER ou LU_EQUILIBRE)  ? ";
                            string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
                            // on test si c'est recevable
                            if (Existe_Enum_type_resolution_matri(val_string))
                              { val_string = string_inter;bonne_lecture=true;}
                            else
                              { cout << " *** erreur: ce type  n'est pas correcte !! ";};
                           break;
                          }
                      };
                     switch (numa)
                      { case 0:  // préparation de sortie
                          { break;} // normalement cela a déjà été filtré avant
                        case 1: { point_interne_delta_thetai_maxi = val_double;tab_modif(numa)=true;break;}
                        case 2: { point_interne_prec_thetai_interne = val_double;tab_modif(numa)=true;break;}
                        case 3: { point_interne_nb_boucle_sur_delta_thetai = val_int;tab_modif(numa)=true;break;}
                        case 4: { point_interne_nb_externe= val_int; tab_modif(numa) = true; break;}
                        case 5: { cal_vol_total_entre_surface_et_plans_ref = val_int;tab_modif(numa)=true;break;}
                        case 6: { ratio_maxi_jacoMembrane_jacoPti = val_double;tab_modif(numa)=true;break;}
                        case 7: { type_calnum_inversion_metrique = Id_nom_resolution(val_string);tab_modif(numa)=true;break;}
                      };
                    // écriture

                  }
                 catch (ErrSortieFinale)
                      // cas d'une direction voulue vers la sortie
                      // on relance l'interuption pour le niveau supérieur
                    { ErrSortieFinale toto;
                      throw (toto);
                    }
                 catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
                  {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour sortir ";
                  };
                }; //-- fin du while interne
               // écriture des paramètres de contrôle
               for (int i=1;i<=nb_choix;i++)
                  if (tab_modif(i))
                   {switch (i)
                      { case 1: { sort << "\n POINT_INTERNE_DELTA_THETAI_MAXI "<< point_interne_delta_thetai_maxi;break;}
                        case 2: { sort << "\n POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne ;break;}
                        case 3: { sort << "\n POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai; break;}
                        case 4: { sort << "\n POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe ;break;}
                        case 5: { sort << "\n CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF "<< cal_vol_total_entre_surface_et_plans_ref ;break;}
                        case 6: { sort << "\n RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti;break;}
                        case 7: { sort << "\n TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique;break;}
                      };
                   };
               break;
             }
           default:
             cout << "\n le cas "<<rep<<" n'est pas  traite !!, bizarre, il faut se plaindre !! ";
          };
        }    
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
        {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                << "\n redonnez une bonne valeur"
                << "\n ou taper f ou 0 pour sortir "; 
        };
      }; //-- fin du while
   sort << "\n   "<<flush;
  
  };


// ramène vraie si le numéro d'increment est nulle modulo la frequence d'affichage d'incrément
// si ce dernier est > 0, sinon =0 modulo la fréquence de sauvegarde si celle-ci est < 0 sinon false
// dans le cas où les sorties s'effectue en fonction du temps, passage du dernier temps de sauvegarde
bool ParaAlgoControle::Vrai_commande_sortie(int icharge,const double& temps_derniere_sauvegarde) const
    { if (frequence_affichage_increment > 0)
         { if ((icharge % frequence_affichage_increment) == 0) return true;}
      else if (frequence_affichage_increment < 0)
         { // cas où on se cale sur la sauvegarde
           bool dernier_calcul = false; // par défaut on considère que ce n'est pas le dernier calcul
           return SauvegardeAutorisee(icharge, temps_derniere_sauvegarde,dernier_calcul);
          }
      return false;    
      };    
              
// indique si la sauvegarde est autorisée, en fonction des paramètres données par l'utilisateur et les variables
// passée en argument
// dernier_calcul : indique si c'est le dernier calcul ou pas 
bool ParaAlgoControle::SauvegardeAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const
  { bool ret=false;
    switch (cas_de_sauvegarde)
     { case 1:
        { // cas d'une sauvegarde par numéro d'incrément
          if (sauvegarde > 0.) { if ((incre % ((int)sauvegarde)) == 0) ret = true;}
          else                 { return  false;}; // cas où sauvegarde == 0
          break;
        }
       case 2:
        { // cas d'une sauvegarde tous les intervals de temps = sauvegarde
          if (sauvegarde >0)
                               { if ((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sauvegarde) return true;}
          else                 { return  false;}; // cas où sauvegarde == 0
          break;
        }
       case 3:
        { // cas d'une sauvegarde uniquement au dernier calcul
          if (dernier_calcul)
                               { return true;}
          else                 { return  false;}; 
          break;
        }
       case 4:
        { // cas d'une sauvegarde par numéro d'incrément + dernier incrément
          if (sauvegarde > 0.) { if (((incre % ((int)sauvegarde)) == 0)|| dernier_calcul) return true;}
          else if (dernier_calcul) {return true;}
          else                     { return  false;}; // cas où sauvegarde == 0
          break;
        }
       case 5:
        { // cas d'une sauvegarde par numéro d'incrément
          if (sauvegarde > 0.) { if (((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sauvegarde)
                                      || dernier_calcul)
                                  return true;
                                }
          else if (dernier_calcul) {return true;}
          else                     { return  false;}; // cas où sauvegarde == 0
          break;
        }

       default:
          cout << "\n *** warning ce n'est pas normal, aucun type de sauvegarde n'est definit ! on continue quand meme ! "
               << endl;
          if (ParaGlob::NiveauImpression() > 3 )
             cout << "\n  ParaAlgoControle::SauvegardeAutorisee(... " << endl;
         break;
     }
    return ret; // au cas où
   }; 

// indique si la sauvegarde au fil du calcul est autorisée, en fonction des paramètres données par l'utilisateur et les variables
// passée en argument
bool ParaAlgoControle::SauvegardeFilCalculAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const
  { bool ret=false;
    if (cas_de_sortie_fil_calcul==1)
      { // cas d'une sauvegarde par numéro d'incrément
		      if (dernier_calcul)
             { ret = true;} // par défaut le dernier calcul est valide
        else if (sortie_fil_calcul > 0.)
             { if ((incre % ((int)sortie_fil_calcul)) == 0)
                 {ret = true;
//cout << "\n debug ParaAlgoControle::SauvegardeFilCalculAutorisee( "
//     << "int sortie_fil_calcul) " << ((int)sortie_fil_calcul)
//     << " (incre % ((int)sortie_fil_calcul)) "<< (incre % ((int)sortie_fil_calcul))
//     << flush;
                 };
                 
             }
        else { ret =  false;}; // cas où sortie_fil_calcul == 0
       }
    else if (cas_de_sortie_fil_calcul == 2)   
      { // cas d'une sauvegarde tous les intervals = sauvegarde
		      if (dernier_calcul)  { ret = true;} // par défaut le dernier calcul est valide
        else         if (sortie_fil_calcul >0)
                             { if ((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sortie_fil_calcul) return true;}
        else                 { ret =  false;}; // cas où sortie_fil_calcul == 0
        }
    else if (cas_de_sortie_fil_calcul == 3)   
      { // cas d'une sauvegarde uniquement au dernier calcul
        if (dernier_calcul)
									 { ret = true;}
        else                 { ret =  false;}; 
        }
    return ret;
   }; 
        
// modification de l'increment de temps, 
// si c'est >= au deltat mini et <= deltat maxi, => retour 0
// modif
// si c'est < au deltat mini   ==> retour -1 : pas de modification du deltat
// si c'est > au deltat maxi  ==> retour 1  : pas de modification du deltat

/* // si c'est < au deltat mini  et que l'on est déjà au temps mini ==> retour -1 : pas de modification du deltat
// si c'est > au deltat maxi et que l'on est déjà au temps maxi ==> retour 1  : pas de modification du deltat

// si c'est > au deltat maxi et que l'on est < au temps maxi ==> retour 3 : pas de modification du deltat
// si c'est < au deltat mini  et que l'on est > au temps mini ==> retour 4 : pas de modification du deltat */


int ParaAlgoControle::Modif_Deltat(double nouveau_temps) 
   {  int retour=0;
      // le cas sans pb
      if ((tempo_specifique_algo.deltatmini <= nouveau_temps) && (nouveau_temps <= tempo_specifique_algo.deltatmaxi))
        {tempo_specifique_algo.deltat = tempo.deltat = nouveau_temps;};

      // cas particuliers
		    if (nouveau_temps > tempo_specifique_algo.deltatmaxi)
		      { retour = 1; }; // cas ou on veut un delta t  plus grand que le maxi, on ne fait rien
		    if (nouveau_temps < tempo_specifique_algo.deltatmini)
        { retour = -1; }; // cas ou l'on veut un delta t  plus petit que le mini, on ne fait rien 
/*		
      if ((tempo.deltat==tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
        // cas ou l'on est déjà au delta t maxi et on veut un delta t encore plus grand, on ne fait rien
        { retour = 1; }
      else  if ((tempo.deltat==tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini)) 
        // cas ou l'on est déjà au delta t mini et on veut un delta t encore plus petit, on ne fait rien 
        { retour = -1; }
      else if ((tempo.deltat < tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
        // cas où le delta t actuel est plus petit que le maxi, et que l'on veut un delta t plus grand que le maxi
        // on ne fait rien
        { retour = 3; //tempo.deltat=tempo.deltatmaxi;
		  }
      else if ((tempo.deltat > tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini))
        // cas où le delta t actuel est plus grand que le mini, et que l'on veut un delta t plus petit que le mini
        // on ne fait rien
        { retour = 4; //tempo.deltat=tempo.deltatmini;
		  };
		  
      else if ((tempo.deltat < tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
        // cas où le delta t actuel est plus petit que le maxi, et que l'on veut un delta t plus grand que le maxi
        // on limite le deltat au deltat maxi, mais il y a modification
        { retour = 0; tempo.deltat=tempo.deltatmaxi;}
      else if ((tempo.deltat > tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini))
        // cas où le delta t actuel est plus grand que le mini, et que l'on veut un delta t plus petit que le mini
        // on limite le deltat au deltat mini, mais il y a modification
        { retour = 0; tempo.deltat=tempo.deltatmini;}
		  
		  
		  ;
        
//      if ((nouveau_temps == tempo.deltatmaxi) || (nouveau_temps == tempo.deltatmini))
//      	{ retour = 0; } // on ne change rien
//      else if ((nouveau_temps < tempo.deltatmini ) { retour = -1;}
//      else if (tempo.deltatmaxi < nouveau_temps ) { retour = 1;};     */ 	
      
      return retour;  
    };
    
// modification de l'incrément dans les bornes
// si nouveau_temps < deltat mini ==> nouveau_temps = deltat mini
// si nouveau temps > deltat maxi ==> nouveau_temsp = deltat maxi
// sinon on laisse le delta_t à la valeur qu'il a actuellement
// ramène oui ou non si ça a été modifié
bool ParaAlgoControle::Modif_Detat_dans_borne(double& nouveau_temps)
	{ bool modif=false;
   if (nouveau_temps < tempo_specifique_algo.deltatmini)
	     {tempo_specifique_algo.deltat = tempo.deltat = tempo.deltatmini;
       nouveau_temps = tempo.deltat;modif=true;
      };
	  if (nouveau_temps > tempo_specifique_algo.deltatmaxi)
	     {tempo_specifique_algo.deltat = tempo.deltat = tempo.deltatmaxi;
       nouveau_temps = tempo.deltat;modif=true;
      };
   return modif;
	};

// mise à jour éventuel du pas de temps et du pas de temps maxi et mini dans le cas où ils sont définit avec des coeff
// d'un pas critique, ramène true s'il y a eu modification du pas de temps courant, false sinon
// temps_critique : temps critique de l'algorithme
// temps_critiqueDFC : temps critique de l'algo DFC = condition de courant
bool ParaAlgoControle::Modif_Deltat_DeltatMaxi(double temps_critique, double temps_critiqueDFC)
  { bool modif=false;
    if (coef_pas_critique_deltat!= coef_defaut_pa_critique) 
      {// cas ou le coef multiplicateur du pas critique a été donné par l'utilisateur c'est-a-dire
       // que le deltat voulu est une fraction du deltat critique
       if (typeDFC_pas_critique_deltat)
            {tempo_specifique_algo.deltat = tempo.deltat
                 = coef_pas_critique_deltat * temps_critiqueDFC - ConstMath::trespetit; modif = true;}
       else {tempo_specifique_algo.deltat = tempo.deltat
                 = coef_pas_critique_deltat * temps_critique - ConstMath::trespetit; modif = true;}
      };
    if (coef_pas_critique_deltatmaxi != 0.) 
      {if (typeDFC_pas_critique_deltatmaxi)
            {tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
                 = coef_pas_critique_deltatmaxi * temps_critiqueDFC; }
       else  {tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
                 = coef_pas_critique_deltatmaxi * temps_critique; };
      }
    if (coef_pas_critique_deltatmini != -3333256794.) 
      {if (typeDFC_pas_critique_deltatmini)
            {tempo_specifique_algo.deltatmini = tempo.deltatmini
                 = coef_pas_critique_deltatmini * temps_critiqueDFC; }
       else {tempo_specifique_algo.deltatmini = tempo.deltatmini
                 = coef_pas_critique_deltatmini * temps_critique; };
      };
    return  modif; 
   };       

// on met à jour les infos globales
std::vector <double>& ParaAlgoControle::Mise_a_jour_Grandeurs_globales()
  {return ParaGlob::Mise_a_jour_Grandeurs_globales();};


