// 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/>.

#include "I_O_Condilineaire.h"
#include "CharUtil.h"
#include <fstream>
#include <sstream>
#include <cstring>
#include <limits>


# include <iostream>
using namespace std;  //introduces namespace std

// par défaut
I_O_Condilineaire::I_O_Condilineaire():
  Condilineaire()
  ,nom_maillage(NULL),refe("")
  ,t_min(0.),t_max(ConstMath::tresgrand),echelle(1.)
  ,precedent(false),valeur_precedente_t(0.)
  ,tab_co_charge(),refs_associe(),enu(NU_DDL)
  ,nom_mail_associe()
  ,condition_relative(false)
  ,fctch(),delta_fctch(),nbddlfamille(0)
  ,def_auto_par_rotation(false),stricte_egalite(false)
  ,type_centre(1),mailEtNumCentreNoeud(),centre_noeud(NULL)
  ,pl(),dr()
    {};
    

// de copie
I_O_Condilineaire::I_O_Condilineaire(const I_O_Condilineaire& nd):
  Condilineaire(nd)
  ,nom_maillage(NULL),refe(nd.refe)
  ,t_min(nd.t_min),t_max(nd.t_max),echelle(nd.echelle)
  ,precedent(nd.precedent),valeur_precedente_t(nd.valeur_precedente_t)
  ,tab_co_charge(nd.tab_co_charge),refs_associe(nd.refs_associe)
  ,nom_mail_associe(nd.nom_mail_associe),enu(nd.enu)
  ,condition_relative(nd.condition_relative)
  ,fctch(nd.fctch),delta_fctch(nd.delta_fctch),nbddlfamille(nd.nbddlfamille)
  ,def_auto_par_rotation(nd.def_auto_par_rotation),stricte_egalite(nd.stricte_egalite)
  ,type_centre(nd.type_centre),centre_rotation(nd.centre_rotation)
  ,mailEtNumCentreNoeud(nd.mailEtNumCentreNoeud),centre_noeud(nd.centre_noeud)
  ,pl(nd.pl),dr(nd.dr)
    {if (nd.nom_maillage != NULL)
         nom_maillage = new string (*(nd.nom_maillage));
     };

// DESTRUCTEUR : 
I_O_Condilineaire::~I_O_Condilineaire()
	{ if (nom_maillage != NULL) 
  	   delete nom_maillage;
	};
				        
// examine si la condition passée en argument possède les mêmes cibles que this
// mais que les data associés sont différents
// ramène true si c'est vrai, false sinon
// en fait cette fonction est définit par conformité avec le programme de lecture 
// LectBloc<T>::Lecture(.. mais ici on peut avoir plusieurs conditions linéaire
// sur la même référence, donc on ramène toujours false
bool I_O_Condilineaire::MemeCibleMaisDataDifferents(I_O_Condilineaire& )        
	{ return false;  
	};
    
    
// Affiche les donnees 
void I_O_Condilineaire::Affiche () const 
   { // affichage éventuelle du nom de maillage
     if (nom_maillage != NULL)
       { cout << "\n nom_mail= " << *nom_maillage;} else cout << "\n";	
	    // puis le reste
     cout << " ref_princ= " << refe ;
     if (refs_associe.Taille() != 0)
     	{int tai = refs_associe.Taille();
       cout << " ref_associe= ";
       for (int i=1;i<=tai;i++)
         if (nom_maillage != NULL) 
            {cout << nom_mail_associe(i) << " " << refs_associe(i) << " ";}
         else   
            {cout  << refs_associe(i) << " ";}
     	};
     cout << "\n type_ddl= " << Nom_ddl(enu) ;
     cout <<  " def_auto_par_rotation= " << def_auto_par_rotation;
     cout <<  " stricte_egalite= " << stricte_egalite;
//     if (!def_auto_par_rotation)
//      { cout << " val_condi= " << this->beta << " coefficients= " << val;}
//     else
//      {if (type_centre == 1)
//        { cout << " centre_fixe= " ;
//          if (ParaGlob::Dimension() == 2) {cout << dr.PointDroite() << " " ;}
//          else {cout << pl.PointPlan() << " " ;};
//        }
//       else if  (type_centre == 2) 
//        { cout << " centre_noeud_t0= " << mailEtNumCentreNoeud << " ";} 
//       else if  (type_centre == 3) 
//        { cout << " centre_noeud_t= " << mailEtNumCentreNoeud << " ";};
//       if (ParaGlob::Dimension() == 2)
//         {cout << " dir_droite_now= " << dr.VecDroite() <<  " dir_droite0= " << val;}
//       else // cas dimension 3
//         {cout << " normal_plan_now= " << pl.Vecplan() << " normal_plan0= " << val;}
//      };

     int dima = ParaGlob::Dimension();
     if(ParaGlob::AxiSymetrie())
       // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
       // dimension-1 coordonnées donc on décrémente
       dima--;
    
     if (def_auto_par_rotation)
      {if (type_centre == 1)
        { cout << " centre_fixe= " ;
          if (dima == 2) {cout << dr.PointDroite() << " " ;}
          else {cout << pl.PointPlan() << " " ;};
        }
       else if  (type_centre == 2) 
        { cout << " centre_noeud_t0= " << mailEtNumCentreNoeud << " ";} 
       else if  (type_centre == 3) 
        { cout << " centre_noeud_t= " << mailEtNumCentreNoeud << " ";};
       if (dima == 2)
         {cout << " dir_droite_now= " << dr.VecDroite() <<  " dir_droite0= " << val;}
       else // cas dimension 3
         {cout << " normal_plan_now= " << pl.Vecplan() << " normal_plan0= " << val;}
      }
     else if (stricte_egalite)
      {   }
     else
      { cout << " val_condi= " << this->beta << " coefficients= " << val;};
    
    
    
     cout << " temps_mini= " << t_min << " temps_maxi= " << t_max
          << " echelle= " << echelle
          << " activite_actuelle: " << precedent      
	         << "  condition_relative= " << condition_relative << " ";
     cout << " courbe_charge= " << tab_co_charge;
     cout << endl;            
   };
		
		 
// Realise l'egalite 		
I_O_Condilineaire& I_O_Condilineaire::operator= (const I_O_Condilineaire& d)
  {// traitement du nom de maillage éventuel  
   if (d.nom_maillage == NULL)
    {if (nom_maillage != NULL)
       {delete nom_maillage;nom_maillage=NULL; nom_mail_associe.Change_taille(0);}
    }
   else
   	{if (nom_maillage == NULL)
   		{nom_maillage = new string (*(d.nom_maillage));
   	     nom_mail_associe = d.nom_mail_associe;
   	     }
     else 
     	{*nom_maillage = *(d.nom_maillage);
         nom_mail_associe = d.nom_mail_associe;
         };
   	};
   // nom de la référence
   refe = d.refe;
   // tableau de références associé
   refs_associe = d.refs_associe;
   // les temps
   t_min = d.t_min; t_max = d.t_max;
   echelle = d.echelle;
   precedent = d.precedent;
	  valeur_precedente_t = d.valeur_precedente_t;
   // l'énuméré
   enu = d.enu;
	  nbddlfamille = d.nbddlfamille;
   // la relativité de la condition
   condition_relative = d.condition_relative;
   // les courbes de charge
   tab_co_charge = d.tab_co_charge;
   def_auto_par_rotation = d.def_auto_par_rotation;
   stricte_egalite = d.stricte_egalite;
   type_centre = d.type_centre;
	  centre_rotation = d.centre_rotation;
   mailEtNumCentreNoeud = d.mailEtNumCentreNoeud;
   centre_noeud = d.centre_noeud;
   pl = d.pl;
   dr = d.dr;
   
   // la condition linéaire
   this->Condilineaire::operator=(d);	
   // retour
   return *this;  
  };
	
//Surcharge d'operateur logique
bool I_O_Condilineaire::operator == ( I_O_Condilineaire& a) const
{  // traitement du nom de maillage éventuel  
   if (nom_maillage == NULL)
      { if (a.nom_maillage != NULL) return false;        
       }
   else
      { if (a.nom_maillage == NULL) return false;
        // sinon les deux sont non null: on test leur égalité
        if (*nom_maillage != *(a.nom_maillage)) return false;         
       }; 
   int dima = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   // cas des centres de rotation éventuelles, il peut y avoir des données qui ne servent pas
   // qui soient différentes, alors que celles qui servent sont identiques !
   if (def_auto_par_rotation != a.def_auto_par_rotation) return false;
   if (stricte_egalite != a.stricte_egalite) return false;
   if (def_auto_par_rotation)
    { if (type_centre != a.type_centre)   return false;
      switch (type_centre)
   	   { case 1: switch (dima)
   	              { case 2: if (dr.PointDroite() != a.dr.PointDroite()) return false; break;
   	                case 3: if (pl.PointPlan() != a.pl.PointPlan()) return false; break;
   	              };
   	     case 2: case 3: if (centre_noeud != a.centre_noeud) return false; break;
   	   };
   	  switch (dima)
   	   { case 2: if (dr.VecDroite() != a.dr.VecDroite()) return false; break;
   	     case 3: if (pl.Vecplan() != a.pl.Vecplan()) return false; break;
   	   };
    }
   else if (stricte_egalite)
    { }
   else
    {if (this->beta != a.beta) return false;
     if (val != a.val) return false;
     };
       
   // les autres données    
   if ( (refe==a.refe) && (refs_associe==a.refs_associe) 
         && (nom_mail_associe == a.nom_mail_associe)
         && (t_min == a.t_min) && (t_max == a.t_max)
         && (echelle == a.echelle)
         && (precedent ==a.precedent) 
         && (enu == a.enu) && (tab_co_charge == a.tab_co_charge)
         && (condition_relative == a.condition_relative) 
       )
     {return true;}
   else 
     {return false; };    
 } ;
	 
         		
// lecture de la condition linéaire sur le fichier d'entree
void I_O_Condilineaire::Lecture(UtilLecture & entreePrinc) 
{ // on regarde tout d'abord si il y a un nom de maillage, qui doit être le premier nom
  int dima = ParaGlob::Dimension();
  if(ParaGlob::AxiSymetrie())
    // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les 
    // dimension-1 coordonnées donc on décrémente
    dima--;
  string nom;
  *(entreePrinc.entree) >> nom;
  if (nom == "nom_mail=")
      { // cas où il y a un nom de maillage
        *(entreePrinc.entree) >> nom; // lecture du nom
        if (nom_maillage == NULL) { nom_maillage = new string(nom);}
        else                      { *nom_maillage = nom;};  	
        // puis on prépare la suite en lisant la référence principale
        *(entreePrinc.entree) >> nom;
      };
  // lecture de la reference
  refe = nom;          
  if (refe.length() == 0)
      { // pas de  reference
        cout << "\n erreur de lecture d'une reference de condition limite lineaire "
             << " le nom de la reference a une longueur nulle \n";
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
      };
   // maintenant on lit les autres informations
   // on lit l'énuméré
   *(entreePrinc.entree) >> nom;
   if (nom != "enu=")    
      { // pas d'énuméré
        cout << "\n erreur de lecture d'une reference de condition limite lineaire "
             << " on attendait enu= , et on a lue: " << nom << " ";
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
      }
   else
      { *(entreePrinc.entree) >> nom;
        if (!ExisteEnum_ddl(nom))
         { // énuméré incorrecte
           cout << "\n erreur de lecture de l'enumere de condition limite lineaire, il n'existe pas "
                << " dans la liste des enumeres correctes: on a lue: " << nom << " ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
         else // on sauvegarde le premier ddl de la famille
          {enu = PremierDdlFamille(Id_nom_ddl(nom));};
      };
   // on passe une ligne
   entreePrinc.NouvelleDonnee(); // on passe un enregistrement
   bool passer_une_ligne = false;
   // lecture des références associées éventuellement
   if (strstr(entreePrinc.tablcar,"refs_associe=")!=NULL)
   	{ *(entreePrinc.entree) >> nom;
      if (nom != "refs_associe=")    
         { // pas de mot clé
           cout << "\n erreur de lecture des references associees pour un  condition limite lineaire "
                << " on attendait refs_associe= , et on a lue: " << nom << " ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
      else
      	{  // lecture de la liste demandée
           int compteur=0; // pour éviter une boucle infinie
           // il y a deux types de lecture suivant qu'il doit y avoir un nom de maillage ou pas
           if (nom_maillage == NULL)
            {list <string> list_inter;
             while (compteur < 1000)
              {(*entreePrinc.entree) >> nom; compteur++;
               // gestion d'erreur
               if (nom == "nom_mail=")
                { // cas où il y a un nom de maillage
                  cout << "\n erreur en lecture : on a lue: " << nom << " or la ref "
                       << " principal ne comporte pas de nom de maillage, dans ce cas les ref"
                       << " secondaires ne doivent pas comporter de nom de maillage !! ";
                  entreePrinc.MessageBuffer("*** lecture des  references secondaire d'une condition lineaire ****" );
                  throw (UtilLecture::ErrNouvelleDonnee(-1));
                  Sortie(1);     
                };
               // suite normale
               if (nom != "fin_list_refs_associe_")
                  {list_inter.push_back(nom);}
               else break;
              };
             // recopie dans le tableau
             int taille = list_inter.size();
             refs_associe.Change_taille(taille);
             list <string>::iterator it,itfin=list_inter.end();
             int i=1;
             for (it = list_inter.begin();it!=itfin;it++,i++) 
                refs_associe(i)=*it;
            }
           else
            // cas où il est possible qu'on lise nom de maillage 
            // de plus il faut attribuer un nom de maillage à chaque ref associé
            {list <Deux_String> list_inter;
             string nom_mail;
             while (compteur < 1000)
              {(*entreePrinc.entree) >> nom; 
               if (nom == "nom_mail=")
                 // cas où il y a un nom de maillage
                 {*(entreePrinc.entree) >> nom_mail; // lecture du nom
                  *(entreePrinc.entree) >> nom; // lecture de la référence
                 }
               else   
                 {nom_mail=*nom_maillage;}; // attribution du nom de maillage générique
              compteur++;
               if (nom != "fin_list_refs_associe_")
                  {list_inter.push_back(Deux_String(nom_mail,nom));}
               else break;
              };
             // recopie dans le tableau
             int taille = list_inter.size();
             refs_associe.Change_taille(taille);nom_mail_associe.Change_taille(taille);
             list <Deux_String>::iterator it,itfin=list_inter.end();
             int i=1;
             for (it = list_inter.begin();it!=itfin;it++,i++) 
                {nom_mail_associe(i)=(*it).nom1;refs_associe(i)=(*it).nom2;}
            };
           passer_une_ligne = true;    
      	};    
   	};
   // on récupère l'échelle globale éventuellement
   if(strstr(entreePrinc.tablcar,"ECHELLE:")!=0)
     { // cas où il y a un facteur d'échelle
       *(entreePrinc.entree)  >> nom;
       if (nom != "ECHELLE:")
         {cout << "\n erreur de syntaxe en lecture du facteur d'echelle "
               << " on attendait le mot cle  ECHELLE: et on a lue " << nom << " ";
          entreePrinc.MessageBuffer("**erreur lecture d'une reference de condition lineaire **");
          throw (UtilLecture::ErrNouvelleDonnee(-1));
          Sortie(1);          
          }
        // lecture du facteur
        *(entreePrinc.entree)  >> echelle; 
     }
   else
     // sinon on met l'échelle à 1
     { echelle = 1. ;}; //-- fin récup de l'échelle

   // lecture d'un tmin et/ou tmax éventuel
   if (strstr(entreePrinc.tablcar,"TEMPS_MINI=")!=NULL)
     { *(entreePrinc.entree) >> nom;
       if (nom != "TEMPS_MINI=")    
          { // pas d'énuméré
            cout << "\n erreur de lecture: position du TEMPS_MINI=  pour un  condition limite lineaire "
                 << " on attendait TEMPS_MINI= , et on a lue: " << nom << " ";
            entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
            throw (UtilLecture::ErrNouvelleDonnee(-1));
            Sortie(1);     
           }
       else
           {(*entreePrinc.entree) >> t_min;passer_une_ligne = true;};    
     };
   if (strstr(entreePrinc.tablcar,"TEMPS_MAXI=")!=NULL)
     { *(entreePrinc.entree) >> nom;
       if (nom != "TEMPS_MAXI=")    
          { // pas d'énuméré
            cout << "\n erreur de lecture: position du TEMPS_MAXI=  pour un  condition limite lineaire "
                 << " on attendait TEMPS_MAXI= , et on a lue: " << nom << " ";
            entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
            throw (UtilLecture::ErrNouvelleDonnee(-1));
            Sortie(1);     
           }
       else
           {(*entreePrinc.entree) >> t_max;passer_une_ligne = true;};
     };
   // lecture éventuel de l'indicateur de condition relative
   condition_relative = false; // faux par défaut
   if (strstr(entreePrinc.tablcar,"CONDITION_RELATIVE=")!=NULL)
     {*(entreePrinc.entree) >> nom;
      if (nom != "CONDITION_RELATIVE=")    
         { cout << "\n erreur de lecture: position de  CONDITION_RELATIVE= erronee, pour un  condition "
                << " limite lineaire,  on attendait CONDITION_RELATIVE= , et on a lue: " << nom << " ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
      else
      	   {(*entreePrinc.entree) >> condition_relative; passer_une_ligne = true;};
      // il y a une vérification concernant la présence de courbe de charge après la lecture de ces dernières
     };
       
   // on passe une ligne pour lire les coefficients de la condition linéaire     	
   if (passer_une_ligne) entreePrinc.NouvelleDonnee(); // on passe éventuellement un enregistrement
   passer_une_ligne = false;
   
   // --- on regarde s'il s'agit d'une définition de linéarité / à une droit ou un plan
   if (strstr(entreePrinc.tablcar,"def_auto_coef_planOuDroite_")!=NULL)
   	{ if (dima == 1)
         { cout << "\n erreur de lecture: on ne peut pas faire de definition automatique avec la dimension 1 ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          };
   	  def_auto_par_rotation = true; // on signale une condition automatique
   	  *(entreePrinc.entree) >> nom; // on passe le mot clé
      if (nom != "def_auto_coef_planOuDroite_")    
         { cout << "\n erreur de lecture: position de  def_auto_coef_planOuDroite_ erronee, pour un  condition "
                << " limite lineaire,  on attendait def_auto_coef_planOuDroite_ , et on a lue: " << nom << " ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          };
      // on vérifie qu'il n'y a pas de référence associée car ce cas n'est pas prévu (ni possible a priori)
      if (refs_associe.Taille() != 0)    
         { cout << "\n erreur de lecture: dans le cas du condition lineaire automatique avec ligne ou plan "
                << " on ne peut pas avoir de reference associe ";
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          };
       // dans le cas où on a lue un enum UX pb, car la projection concerne les positions et non les déplacements
       // sinon il faut utiliser une condition générale
      if (enu != X1)    
       { cout << "\n erreur de coherence: dans le cas du condition lineaire automatique avec ligne ou plan "
        << " on ne peut pas utiliser comme enumere: " << Nom_ddl(enu) ;
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
      // ici l'échelle doit être égale à 1, on vérifie, pour des pb de projection et d'algo d'ensemble
      if (echelle != 1.)    
       { cout << "\n erreur de coherence: dans le cas du condition lineaire automatique avec ligne ou plan "
              << " on ne peut pas utiliser une echelle (ici= " << echelle << " ) differente de 1. !! " ;
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
      // ici on ne doit pas avoir de condition relative car ça ne signifie rien pour la projection, on vérifie, 
      if (condition_relative)    
       { cout << "\n erreur de coherence: dans le cas du condition lineaire automatique avec ligne ou plan "
        << " on ne peut pas utiliser une condition relative (cela ne signifie rien dans le cas d'une projection ) !! " ;
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);     
       };
		
		
      // maintenant on lit le centre
      *(entreePrinc.entree) >> nom; 
      // on met à jour la dimension des plan droite
      switch (dima)
           	{ case 2: dr.Change_dim(dima);break;
           	  case 3: pl.Change_dim(dima);break;
           	};

      if (nom == "centre_fixe_") 
         { type_centre = 1; 
           Coordonnee centre_rotation(dima);
           centre_rotation.Lecture(entreePrinc);
           switch (dima)
           	{ case 2: dr.Change_ptref(centre_rotation); break;
           	  case 3: pl.Change_ptref(centre_rotation); break;
           	}
         }
       else if ((nom == "centre_noeud_a_t0_") || (nom == "centre_noeud_a_t_"))   
         { if (nom == "centre_noeud_a_t0_")     {type_centre = 2;} 
           else if (nom == "centre_noeud_a_t_") {type_centre = 3;}; 
           // cas d'un centre donné par un numero de noeud
           string nom_mail;
           *(entreePrinc.entree) >> nom_mail;
           if (nom_mail == "nom_mail=")
                { // cas où il y a un nom de maillage
                  *(entreePrinc.entree) >> mailEtNumCentreNoeud.nom; // lecture du nom
                  *(entreePrinc.entree) >> mailEtNumCentreNoeud.n; // lecture du numero de noeud
                }
           else 
            	{ // sinon cela veut dire que l'on vient de lire un numéro de noeud du premier maillage
            	  mailEtNumCentreNoeud.nom = "";
            	  mailEtNumCentreNoeud.n = ChangeEntier(nom_mail); 	
            	}; 
         }
       else   
         { cout << "\n erreur de lecture: on attendait : centre_fixe_ ou centre_noeud_a_t0_ "
                << " ou centre_noeud_a_t_ et on a lue: " << nom ;
           entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          };
       // puis on lit la normale ou la direction de la droite qui correspond aux composantes de val ici
   	}
   else {def_auto_par_rotation = false;	};
 
   // -- on regarde s'il s'agit d'une condition de stricte egalité entre noeud pour le type enu
   if (strstr(entreePrinc.tablcar,"stricte_egalite_")!= NULL)
    {   }
   else {stricte_egalite = false;};
   
   // dans un cas normal on lit une valeur de la condition linéaire 
   if ((!def_auto_par_rotation)&&(!stricte_egalite))
     {// lecture de la valeur de la condition limite
      *(entreePrinc.entree) >> nom;
      if (nom != "val_condi_lineaire=")    
        { cout << "\n erreur de lecture: val_condi_lineaire  pour un  condition limite lineaire "
               << " on attendait val_condi_lineaire= , et on a lue: " << nom << " ";
          entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
          throw (UtilLecture::ErrNouvelleDonnee(-1));
          Sortie(1);     
        }
      else
    	   { (*entreePrinc.entree) >> beta;};
     };
 
   if (!stricte_egalite) // dans le cas stricte_egalité, la lecture est finie
    { // lecture des coefficients de la condition linéaire
      *(entreePrinc.entree) >> nom;
      if (nom != "coefficients=")    
       { // pas d'énuméré
         cout << "\n erreur de lecture des coefficients de la  condition limite lineaire "
              << " on attendait coefficients= , et on a lue: " << nom << " ";
         entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
         throw (UtilLecture::ErrNouvelleDonnee(-1));
         Sortie(1);     
       }
      else
       { // lecture de la liste demandée
         int compteur=0; // pour éviter une boucle infinie
         list <double> list_inter; 
         while (compteur < 1000)
           { (*entreePrinc.entree) >> nom; compteur++;
            if (nom != "fin_list_coefficients_")
              { list_inter.push_back(ChangeReel(nom));}
            else break;                           
           };
         // recopie dans le tableau
         int taille = list_inter.size();
         val.Change_taille(taille);
         list <double>::iterator it,itfin=list_inter.end();
         int i=1;
         for (it = list_inter.begin();it!=itfin;it++,i++) 
            val(i)=*it;
         // on vérifie que le nombre de coefficients est correcte
         Tableau<Enum_ddl> tab_enu = TableauTypeDdlmobileAvecAxi(enu);
         nbddlfamille = tab_enu.Taille();
         if (taille != nbddlfamille * (1+refs_associe.Taille()))
          { cout << "\n erreur de lecture des coefficients de la condition lineaire, leur nombre  " << taille
                 << " est differente de (1 + le nombre de reference associe)*le nombre de ddl de la famille = " 
                 << nbddlfamille * (1+refs_associe.Taille()) << " ";
            if(ParaGlob::AxiSymetrie()) cout << "(ici en axi) ";
            entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
            throw (UtilLecture::ErrNouvelleDonnee(-1));
            Sortie(1);     
          };
         if (def_auto_par_rotation)
          {// on met à jour la direction ou la normale droite plan 
           switch (dima)
             { case 2: dr.Change_vect(val.Coordo()); break;
               case 3: pl.Change_normal(val.Coordo()); break;
             }
          };
       };
      // on regarde s'il faut considérer des fonctions de charge
      tab_co_charge.Libere(); // par défaut on initialise le tableau à 0	
      if (strstr(entreePrinc.tablcar,"AvecFonctionsDeCharges_")!=NULL)
        {entreePrinc.NouvelleDonnee(); // on passe un enregistrement
         // lecture du mot clé de début
         (*entreePrinc.entree) >> nom;
         if (nom != "deb_fonction_de_charge=")    
            { cout << "\n erreur de lecture d'une liste de fonctions de charge  "
                   << " pour un  condition limite lineaire "
                   << " on attendait deb_fonction_de_charge= , et on a lue: " << nom << " ";
              entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
              throw (UtilLecture::ErrNouvelleDonnee(-1));
              Sortie(1);     
            }
         else
          {  // lecture de la liste demandée
              int compteur=0; // pour éviter une boucle infinie
              list <string> list_inter;
              while (compteur < 1000)
               { (*entreePrinc.entree) >> nom; compteur++;
                 if (nom != "fin_list_fonctions_de_charges_")
                   { list_inter.push_back(nom);}
                 else break;                           
               };
              // recopie dans le tableau
              int taille = list_inter.size();
              int i=1;
              // dans le cas plan ou droite, par analogie au cas générale on considère une taille 
              // telle que c'est seulement à partir du  second élément que l'on travaille
              // on double le premier élément, pour permettre aux boucles de fonctionner, mais le premier
              // élément ne sert pas dans le calcul de la condition !!
              if (def_auto_par_rotation) {taille++;i=2;};
              
              tab_co_charge.Change_taille(taille);
                    list <string>::iterator it,itfin=list_inter.end();
                    for (it = list_inter.begin();it!=itfin;it++,i++) 
                       tab_co_charge(i)=*it; 
              if (def_auto_par_rotation)  tab_co_charge(1) = tab_co_charge(2);  // doublage du premier élément
          };
         // il doit y avoir autant de nom de fonction de charge que de coef + 1 pour la valeur
         if (tab_co_charge.Taille() != (val.Taille() + 1))  	
            { cout << "\n erreur de lecture d'une liste de fonctions de charge  "
                   << " pour un  condition limite lineaire "
                   << " le nombre de fonctions de charge lue (ici: " << tab_co_charge.Taille();
              if (def_auto_par_rotation)
                { cout << " ) doit etre egal au nombre de coefficient  pour la valeur de condition lineaire de projection "
                       << " ce qui devrait faire : " <<  (val.Taille()) << " ";
                }
              else
                { cout << " ) doit etre egal au nombre de coefficient + 1 pour la valeur de condition lineaire "
                       << " ce qui devrait faire : " <<  (val.Taille() + 1) << " ";
                };
              entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
              throw (UtilLecture::ErrNouvelleDonnee(-1));
              Sortie(1);
            };
        }
      else if (condition_relative)
        {// cas où il n'y a pas de fonction de charge, mais que l'on a indiqué une condition relative
         cout << "\n **** Warning !!! les conditions lineaires relatives ne fonctionnent que avec des courbes de charge "
              << " dans le cas de conditions simples (fixes) on se refere toujours a la situation a t=0 " << endl;
         condition_relative = false;                  		
        };
    }
   else
    {// quelques vérifs au cas où
     if (echelle != 1.)
      { cout << "\n erreur de coherence: dans le cas d'une condition stricte_egalite_ "
             << " on ne peut pas utiliser une echelle (ici= " << echelle << " ) differente de 1. !! " ;
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      };
    if (  (strstr(entreePrinc.tablcar,"coefficients=")!= NULL)
        ||(strstr(entreePrinc.tablcar,"CONDITION_RELATIVE=")!= NULL)
       )
      { cout << "\n erreur de coherence: dans le cas d'une condition stricte_egalite_ "
             << " on ne peut pas utiliser les mots cles coefficients= , CONDITION_RELATIVE= !! " ;
        entreePrinc.MessageBuffer("*** lecture d'une reference de condition lineaire ****" );
        throw (UtilLecture::ErrNouvelleDonnee(-1));
        Sortie(1);
      };
    condition_relative = false;
    tab_co_charge.Libere();
    };
   // initialisation des grandeurs de travail
   Initialisation_condil();  
 };
 
// affichage des commandes particulières à la définition d'une condition linéaire
void I_O_Condilineaire::Info_commande_conditionLineaire(ofstream & sort,bool plusieurs_maillages)
 {
   //On va proposer un menu pour choisir entre différents types de conditions linéaires
   int type_CLL=0; // =0 non défini, =1 -> projection sur un plan ou une droite
                   // =2 -> condition générale
   {string rep=" ";
    // tableau des choix possibles
    Tableau <string> tab_choix(6);
    tab_choix(1) =  "\n (0 ou f)  (fin)        ";
    tab_choix(2) =  "\n (1)  info detaillees dans le fichier .info";
    tab_choix(3) =  "\n (2 ou ?)  informations succinctes a l ecran";
    tab_choix(4) =  "\n (3) CLL: proj sur plan en 3D (droite en 2D) ";
    tab_choix(5) =  "\n (4) CLL: generale     ";
    tab_choix(6) =  "\n (5) CLL: stricte_egalite     ";
  
    while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
       {
        try 
         { for (int i=1;i<=tab_choix.Taille();i++)
              cout << tab_choix(i);
           cout << "\n rep : ";
           rep = lect_return_defaut(false,"f"); cout << " grandeur lue " << rep;
           int num = 0; // par défaut
           if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
            // on ne fait rien
            {num = 0;}
           else
            { num = ChangeEntier(rep);
              if (Minuscules(rep) == "?")
                num = 2;
              bool choix_valide=false;
              if ((num >= 0)&&(num<=5))
                { choix_valide=true; }
              else { cout << "\n Erreur on attendait un entier entre 0 et 5 !!, "
                          << "\n redonnez une bonne valeur"
                          << "\n ou taper f ou 0 pour arreter le programme";
                     choix_valide=false;
                   };
              switch (num)
               { case 0:  // sortie
                   { break;}
                 case 1:  // sortie documentation détaillée sur le fichier .info
                   {
 sort << "\n# .............................. condition lineaire: mode d'emploi ................................................."
      << "\n# |  NB: de nombreuse grandeurs sont optionelles, par contre l'ordre d'apparition est impose!!                     |"
      << "\n# |  constituee : d'une reference principal de noeud qui peut etre precedee (eventuellement) d'un nom de maillage, |"
      << "\n# |  ex1: N_avant , ex2: nom_mail= solide1  N_avant                                                                |" 
      << "\n# |  suivi sur la meme ligne du type de la famille de ddl sur laquelle s'applique la condition lineaire            |"
      << "\n# |  ex1: enu= UX , ex2: enu=  X1 , ex3 enu= TEMP                                                                  |" 
      << "\n# |  puis sur la ligne qui suit une suite eventuelle de references secondaires, (s'il n'y en a pas, on met rien )  |"
      << "\n# |  sinon on utilise deux mots cle pour encadrer la liste                                                         |"
      << "\n# |  ex1: refs_associe= N_arriere N_milieu  fin_list_refs_associe_                                                 |" 
      << "\n# |  Dans le cas ou la reference principal comporte un nom de maillage, il est possible d'indiquer ou non avant    |" 
      << "\n# |  chaque reference secondaire, un nom de maillage. Si ce nom de maillage est absent, c'est celui de la reference|" 
      << "\n# |  principale qui est retenue a la place. Ainsi, on peut definir une CLL entre des noeuds de maillages           |" 
      << "\n# |  differents. Par contre, si la reference principale ne contient pas de nom de maillage, les references         |" 
      << "\n# |  secondaires ne doivent pas en comporer, sinon cela genere une erreur !                                        |" 
      << "\n# |  les references secondaires doivent avoir exactement le meme nombre de noeud que la reference principal        |"
      << "\n# |  la condition linaire s'appliquera sur chaque noeud de la reference principal, associe aux noeuds de           |"
      << "\n# |  du meme rang des references secondaires: par exemple pour les ex1, la condition lineaire s'applique           |"
      << "\n# |  successivement pour tous noeud i de N_avant, sur le groupe (noeud i de N_avant + noeud i de N_arriere         |"
      << "\n# |  + noeud i de N_milieu). Comme il s'agit de la famille de  ddl de type UX, donc deplacement, en 3D             |"
      << "\n# |  on doit donc avoir 3*3 coef + 1 pour la valeur de la condition = 10 coef pour la condition qui s'ecrit        |"
      << "\n# |  donc : a1 UX(1) + a2 UY(1) + a3 UZ(1) + a4 UX(2) +..... + a9 UZ(3) = a10                                      |"
      << "\n# |  UX(1) correspond au deplacement du noeud de la reference de N_avant, UX(2) pour N_arriere, UX(3)  pour        |"
      << "\n# |  N_milieu, a10 est la condition imposee                                                                        |"
      << "\n# |  Ensuite toujours sur la meme ligne on peut eventuellement indiquer un temps mini et un temps maxi             |"
      << "\n# |  ex1  TEMPS_MINI= 0.1   TEMPS_MAXI=  5.                                                                        |"
      << "\n# |  Puis toujours sur la meme ligne, on peut eventuellement indiquer que la condition est relative ou non         |"
      << "\n# |  par defaut la condition est absolue, cela signifie que l'on se refere a la situation a t=0                    |"
      << "\n# |  dans le cas d'une condition relative, on se refere a la situation precedente: cependant, ce mecanisme         |"
      << "\n# |  ne fonctionne que si dans le cas de l'utilisation de fonction de charge (cf. suite des infos)                 |"
      << "\n# |  ex1 CONDITION_RELATIVE= 1  # =0 absolue, =1 relative                                                          |"
      << "\n# |  NB: tous la ligne: ref secondaire, temps mini maxi, condition realtive, est optionnelle, cela signifie        |"
      << "\n# |  quelle peut ne pas exister du tout, ou comporter quelques elements seulement.                                 |"
      << "\n# |                                                                                                                |"
      << "\n# |  Ensuite sur la ligne suivante et on indique tout d'abord la valeur de la condition lineaire, (correspond à a10|"
      << "\n# |  dans l'exemple 1 ) puis la la liste des coefficients de la conditions lineaire  encadre par 2 mots cle        |"
      << "\n# |  ex1    val_condi_lineaire=  10   coefficients= 1 2 3 4 5 6 7 8 9 10  fin_list_coefficients_                   |"
      << "\n# |  ensuite on indique eventuellement s'il y a des fonctions de charges pour les coefficients avec la presence    |"
      << "\n# |  ou non du mot cle  AvecFonctionsDeCharges_                                                                    |"
      << "\n# | ex1 val_condi_lineaire= 10 coefficients= 1 2 3 4 5 6 7 8 9 10 fin_list_coefficients_ AvecFonctionsDeCharges_   |"
      << "\n# | s'il y a des fonctions de charge, il doit y en avoir exactement le meme nombre que de coefficient+1 (pour      |"
      << "\n# | la valeur de la condition limite )  on a donc une liste de nom de fonction de charge encadree par 2 mots cle   |"
      << "\n# | la premiere fonction de charge s'applique sur la condition, la deuxieme sur le coefficient 1, la ieme sur le   |"
      << "\n# | coefficient i-1. La liste des  noms des fct de charge s'indique sur la ligne qui suit                          |"
      << "\n# | ex1 deb_fonction_de_charge= chc ch1 ch2 ch3 ch4 ch5 ch6 ch7 ch8 ch9 fin_list_fonctions_de_charges_             |"
      << "\n#........................................................................................................................."
      << "\n# exemple complet"
      << "\n   nom_mail= solide1  N_avant  enu= UX  "
      << "\n      refs_associe= nom_mail= solide2 N_arriere N_milieu  fin_list_refs_associe_   TEMPS_MINI= 0.1   TEMPS_MAXI=  5.    "  
      << "\n      val_condi_lineaire=  10   coefficients= 1 2 3 4 5 6 7 8 9   fin_list_coefficients_  AvecFonctionsDeCharges_ "
      << "\n      deb_fonction_de_charge= chc ch1 ch2 ch3 ch4 ch5 ch6 ch7 ch8 ch9 fin_list_fonctions_de_charges_  "
      << "\n#........................................................................................................................."
     << endl;
                   }
                 case 2:  // informations succinctes a l'écran
                   { cout << "\n cas particulier 1 : CLL: proj sur plan en 3D (droite en 2D) "
                          << " --> permet de construire les parametres d'une CLL a partir de la "
                          << " def d'un plan de projection en 3D (ou d'une droite de projection pour le 2D)"
                          << "\n ** warning ** un noeud qui supporte une CLL de projection ne peut pas supporter une autre"
                          << " condition : CL ou CLL !!! ";
                     cout << "\n cas particulier 2 : stricte_egalite_ : c-a-d stricte egalite entre ddl de type enu  "
                          << " --> aucune donnee supplementaire n'est necessaire apres le mot cle stricte_egalite_ "
                          << "\n ** warning ** contrairement aux autres cas : un noeud qui supporte une CLL stricte "
                          << "\n egalite peut egalement supporter une autre condition : CL ou CLL !!! ";
                     cout << "\n CLL: generale --> permet de construire une relation lineaire quelconque entre "
                          << " les ddl d'un ou plusieurs noeuds. Contrairement aux CLL de projection, un noeud peut"
                          << " supporter autant de CL et/ou de CLL qu'il a de ddl libres (mais pas plus sinon une "
                          << " erreur est generee ) "
                          << endl;
                     break;
                   }
                 case 3:  // CLL: proj sur plan en 3D (droite en 2D)
                   { type_CLL = 1; rep = "f"; break;}
                 case 4:  // CLL: generale
                   { type_CLL = 2; rep = "f";break;}
                 case 5:  // CLL: stricte_egalite_
                   { type_CLL = 3; rep = "f";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 << flush;
   };
  
   //maintenant on va renseigner les CLL en fonction du choix effectué
   int dim = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dim--;
   if ((type_CLL == 1) && ( dim != 1))
    {//On va proposer un menu
     string rep=" ";
     string nom_courbe="_";
     double temps_mini = - ConstMath::trespetit;
     double temps_maxi =  ConstMath::tresgrand;
     Coordonnee M(dim); // coordonnées d'un point fixe du plan ou droite
     string nom_mail_centre=" "; // éventuellement
     int numNoeud_0=0; // ou numéro du noeud du plan a t= 0
     int numNoeud_t=0; // ou numéro du noeud du plan a t
     int type_point=0; // =1 pt fixe, =2 noeud initial, =3 noeud final
     Coordonnee N(0); // coordonnées de la normale du plan ou droite
     Tableau <string> tab_Co_charges; // tableau des noms de fonctions de charges
     // tableau des choix possibles
     Tableau <string> tab_choix(9);
     tab_choix(1) =  "\n (0 ou f)  (fin)               ";
     tab_choix(2) =  "\n (1) reference des noeuds ";
     tab_choix(3) =  "\n (2) def d'1 pt fixe du plan via coordonnees ";
     tab_choix(4) =  "\n (3) ou def d'1 pt fixe du plan = noeud a t=0 ";
     tab_choix(5) =  "\n (4) ou def d'1 pt mobile du plan = noeud a tdt ";
     tab_choix(6) =  "\n (5) normale au plan  ";
     tab_choix(7) =  "\n (6) temps mini ";
     tab_choix(8) =  "\n (7) temps maxi ";
     tab_choix(9) =  "\n (8) def fonctions de charge ";
     string nom_ref="";
     ostringstream  flux;
 
     while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
      {
       try 
        { for (int i=1;i<=tab_choix.Taille();i++)
             cout << tab_choix(i);
          cout << "\n >>>  il faut obligatoirement definir (1)+{(2)ou(3)ou(4)}+(5) <<< ";
          cout << "\n rep : ";
          rep = lect_return_defaut(false,"f"); cout << " grandeur lue " << rep;
          if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
            // c'est à la sortie que ce fait l'écriture donc ici
            {sort << "\n";
             if ((nom_ref == " ")||(type_point==0)||(N.Dimension()==0))
               {cout <<"\n ** CLL incomplete, pas d'ecriture ";
                break;
               };
             if (plusieurs_maillages)
               { cout << "\n nom du maillage ? ";
                 string nom_mail;
                 nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
                 sort << "nom_mail= "<< nom_mail << " ";
               };
             sort << nom_ref <<" enu= X1 ";
             // temps mini et maxi éventuel
             if ((temps_mini != - ConstMath::trespetit)||(temps_maxi != ConstMath::tresgrand))
              {sort << "\n";
               if (temps_mini != (- ConstMath::trespetit))
                sort << " TEMPS_MINI= "<< temps_mini<<" ";
               if (temps_maxi != ConstMath::tresgrand)
                sort << " TEMPS_MAXI= "<< temps_maxi<<" ";
              };
             // la condition
             sort << "\n  def_auto_coef_planOuDroite_ ";
             switch (type_point)
              { case 1: sort << " centre_fixe_  "; M.Affiche_1(sort);break;
                case 2: sort << " centre_noeud_a_t0_ " << nom_mail_centre << numNoeud_0; break;
                case 3: sort << " centre_noeud_a_t_ " << nom_mail_centre << numNoeud_t; break;
              };
             // les coefficients
             sort << " coefficients= "; N.Affiche_1(sort);
             sort << " fin_list_coefficients_ ";
             // fonctions de charge éventuelles
             if (tab_Co_charges.Taille() != 0)
              {sort << "  AvecFonctionsDeCharges_ \n deb_fonction_de_charge=  ";
               for (int i=1;i<=tab_Co_charges.Taille();i++)
                 sort << tab_Co_charges(i) << " ";
               sort << " fin_list_fonctions_de_charges_ "<< endl;
              };
             break;
            };
          int num = ChangeEntier(rep);
          bool choix_valide=false;
          if ((num >= 0)&&(num<=8))
               { choix_valide=true; }
          else { cout << "\n Erreur on attendait un entier entre 0 et 8 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper f ou 0 pour arreter le programme";
                 choix_valide=false;
               }
          switch (num)
           { case 0:  // sortie
               { break;}
             case 1:  // reference des noeuds
               { cout << "\n nom de la ref de noeud pour l'application de la condition ? ";
                 nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
                 if (nom_ref.at(0) != 'N')
                  {cout << "\n *** erreur, la premiere lettre de la ref de noeuds "
                        << " doit etre N et non "<< nom_ref.at(0)<< " !! *** "
                        << " \n ** cette ref n'est pas valide !! ** \n ";
                   nom_ref = " "; // on re init
                   break;
                  };
                 break;
               }
             case 2:  // def d'1 pt fixe du plan via coordonnees
               { if (type_point != 0)
                   cout << "\n ** warning vous definissez un nouveau point du plan  "
                        << " qui va donc remplasser votre precedent point  ";
               
                 switch (dim)
                   {case 3:
                      {cout << "\n def d'un pt du plan via la def de ses coordonnees:  ";
                       // comme on a plusieurs entrée on va utiliser un cin
                       cout << "\n donner 3 reels "; for (int i=1;i<4;i++) cin >> M(i);
                       type_point=1; cout << " valeurs lue =";M.Affiche();
                       std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// vide cin
                       break;
                      }
                    case 2:
                       // comme on a plusieurs entrée on va utiliser un cin
                      {cout << "\n donner 2 reels "; for (int i=1;i<3;i++) cin >> M(i);
                       type_point=1; cout << " valeurs lue =";M.Affiche();
                       std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// vide cin
                       break;
                      }
                    default: choix_valide=false; break;
                   };
                 break;
                }
             case 3:  // ou def d'1 pt fixe du plan = noeud a t=0
               { if (type_point != 0)
                   cout << "\n (** warning vous definissez un nouveau point du plan  "
                        << " qui va donc remplasser votre precedent point)  ";
               
                 cout << "\n def numero du noeud dont la position initiale sera un point du plan"
                      << "\n numero ? : ";
                 numNoeud_0 = (int) lect_double();cout << " valeur lue ="<< numNoeud_0;
                 if (plusieurs_maillages)
                   { cout << "\n nom du maillage associe ? ";
                     string nom_mail_centre;
                     nom_mail_centre= lect_chaine(); cout << " nom lu = "<< nom_mail_centre;
                   };
                 type_point=2;
                 break;
                }
             case 4:  //ou def d'1 pt mobile du plan = noeud a tdt
               { if (type_point != 0)
                   cout << "\n (** warning vous definissez un nouveau point du plan  "
                        << " qui va donc remplasser votre precedent point) ";
               
                 cout << "\n def numero du noeud dont la position finale sera un point du plan "
                      << "\n numero ? : ";
                 numNoeud_t=(int)lect_double();cout << " valeur lue ="<< numNoeud_t;
                 if (plusieurs_maillages)
                   { cout << "\n nom du maillage associe ? ";
                     string nom_mail_centre;
                     nom_mail_centre= lect_chaine(); cout << " nom lu = "<< nom_mail_centre;
                   };
                 type_point=3;
                 break;
                }
             case 5:  // def normale au plan
               { cout << "\n normale au plan (ou droite) ? ";
                 N.Change_dim(dim);
                 switch (dim)
                   {case 3:
                      {cout << "\n donner 3 reels "; for (int i=1;i<4;i++) cin >> N(i);
                       cout << " valeurs lue =";N.Affiche();
                       std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );//on vide cin
                       break;
                      }
                    case 2:
                      {cout << "\n donner 2 reels "; for (int i=1;i<3;i++) cin >> N(i);
                       cout << " valeurs lue =";N.Affiche();
                       std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );//on vide cin
                       break;
                      }
                    default:
                      cout << "\n en 1D les CLL de projection ne sont pas possible ";
                      choix_valide=false; break;
                   };
                 break;
               }
             case 6:  // temps mini
                { cout << "\n valeur du temps mini (un reel)  ? ";
                 temps_mini=lect_double();cout << " valeur lue ="<< temps_mini;
                 break;
                }
             case 7:  // temps maxi
                { cout << "\n valeur du temps maxi (un reel)  ? ";
                  temps_maxi=lect_double();cout << " valeur lue ="<< temps_maxi;
                  break;
                }
             case 8:  // def des courbes de charges
               { tab_Co_charges.Change_taille(dim);
                 cout << "\n il faut definir "<<dim<<"courbes de charge";
                 for (int i=1;i<=dim;i++)
                   {cout << "\n nom de la "<<i<<" ieme courbe de charge  ? ";
                    tab_Co_charges(i)= lect_chaine();cout << " nom lu = "<< tab_Co_charges(i);
                   };
                 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
 
    }
   else if (type_CLL == 2)
    {//On va proposer un menu
     string rep=" ";
     string nom_courbe="_";
     double temps_mini = - ConstMath::trespetit;
     double temps_maxi =  ConstMath::tresgrand;
     Coordonnee M(dim); // coordonnées d'un point fixe du plan ou droite
     string nom_mail_centre=" "; // éventuellement
     Coordonnee N(0); // coordonnées de la normale du plan ou droite
     
     Enum_ddl enu=NU_DDL; // enuméré des ddl de la cll
     double val_condi=0.; // valeur par défaut de la condition linéaire
     list <string> list_ref_secondaires; // liste des références secondaires
     list <string> list_mail_secondaires; // la liste des maillages associées à list_ref_secondaires
     Tableau <double> tab_coef_CLL; // tableau des coef de la CLL
     Tableau <string> tab_Co_charges; // tableau des noms de fonctions de charges
     bool condition_relative = false; // par défaut
     // tableau des choix possibles
     Tableau <string> tab_choix(11);
     tab_choix(1) =  "\n (0 ou f)  (fin)               ";
     tab_choix(2) =  "\n (1) reference principale de noeuds ";
     tab_choix(3) =  "\n (2) references secondaires de noeuds ";
     tab_choix(4) =  "\n (3) type de degre de liberte ";
     tab_choix(5) =  "\n (4) valeur de la CLL ";
     tab_choix(6) =  "\n (5) coefficients de la CLL ";
     tab_choix(7) =  "\n (6) condition relative  ";
     tab_choix(8) =  "\n (7) temps mini ";
     tab_choix(9) =  "\n (8) temps maxi ";
     tab_choix(10) =  "\n (9) def fonctions de charge ";
     tab_choix(11) =  "\n (10) test si la CLL est recevable ";
     string nom_ref="";
     ostringstream  flux;
 
     while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
      {
       try 
        { for (int i=1;i<=tab_choix.Taille();i++)
             cout << tab_choix(i);
          cout << "\n >>>  il faut obligatoirement definir a minima (1)+(3)+(4)+(5) <<< "
               << "\n      et de preference dans l'ordre indique ";
          cout << "\n rep : ";
          rep = lect_return_defaut(false,"f"); cout << " grandeur lue " << rep;
          if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
            // c'est à la sortie que ce fait l'écriture donc ici
            {sort << "\n";
             int nb_val = (dim*(list_ref_secondaires.size()+1));
             if ((nom_ref == " ")||(tab_coef_CLL.Taille()!=nb_val)
                 ||((tab_Co_charges.Taille()!=0)&&(tab_Co_charges.Taille()!=nb_val))
                )
               {cout <<"\n ** CLL incomplete, pas d'ecriture ";
                break;
               };
             if (plusieurs_maillages)
               { cout << "\n nom du maillage pour la ref principale ? ";
                 string nom_mail;
                 nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
                 sort << "nom_mail= "<< nom_mail << " ";
               };
             sort << nom_ref <<" enu= " << Nom_ddl(enu);
             // références secondaires éventuelles et / ou
             // temps mini et maxi éventuel
             if ( ((temps_mini != - ConstMath::trespetit)||(temps_maxi != ConstMath::tresgrand))
                 || (list_ref_secondaires.size() != 0))
              {sort << "\n";
               // les ref secondaires
               if (list_ref_secondaires.size() != 0)
                {list <string>::iterator ideb = list_ref_secondaires.begin();
                 list <string>::iterator idfin = list_ref_secondaires.end();
                 list <string>::iterator ill = list_mail_secondaires.begin();
                 sort << " refs_associe= ";
                 if (plusieurs_maillages)
                  {for (;ideb != idfin;ideb++, ill++)
                     sort << "nom_mail= "<< (*ill) << "  " << (*ideb) << " ";
                  }
                 else
                  {for (;ideb != idfin;ideb++, ill++)
                     sort << (*ideb) << " ";
                  };
                 sort << " fin_list_refs_associe_ ";
                };
               // encadrement en temps
               if (temps_mini != (- ConstMath::trespetit))
                sort << " TEMPS_MINI= "<< temps_mini<<" ";
               if (temps_maxi != ConstMath::tresgrand)
                sort << " TEMPS_MAXI= "<< temps_maxi<<" ";
               // le cas d'une condition relative ou pas
               if (condition_relative)
                 sort << " CONDITION_RELATIVE= 1 ";
              };
             // la condition
             sort << "\n  val_condi_lineaire=  " << val_condi << " coefficients= ";
             // les coefficients
             for (int i=1;i<=nb_val;i++)
               sort << tab_coef_CLL(i) << " ";
             sort << " fin_list_coefficients_ ";
             // fonctions de charge éventuelles
             if (tab_Co_charges.Taille() != 0)
              {sort << "  AvecFonctionsDeCharges_ \n deb_fonction_de_charge=  ";
               for (int i=1;i<=tab_Co_charges.Taille();i++)
                 sort << tab_Co_charges(i) << " ";
               sort << " fin_list_fonctions_de_charges_ ";
              };
             sort << endl << std::flush;
             break;
            };
          int num = ChangeEntier(rep);
          bool choix_valide=false;
          if ((num >= 0)&&(num<=10))
               { choix_valide=true; }
          else { cout << "\n Erreur on attendait un entier entre 0 et 8 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper f ou 0 pour arreter le programme";
                 choix_valide=false;
               }
          switch (num)
           { case 0:  // sortie
               { break;}
             case 1:  // reference principale de noeuds
               { cout << "\n nom de la ref de noeud pour l'application de la condition ? ";
                 nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
                 if (nom_ref.at(0) != 'N')
                  {cout << "\n *** erreur, la premiere lettre de la ref de noeuds "
                        << " doit etre N et non "<< nom_ref.at(0)<< " !! *** "
                        << " \n ** cette ref n'est pas valide !! ** \n ";
                   nom_ref = " "; // on re init
                   break;
                  };
                 break;
               }
             case 2:  // references secondaires de noeuds
               {  bool fin = false;
                  string nom_ref_inter=" ";
                  while (!fin)
                    { cout << "\n nom d'une ref de noeud secondaire ou f (ou 0 ou o) pour finir ? ";
                      nom_ref_inter= lect_chaine();cout << " nom lu = "<< nom_ref_inter;
                      if ((Minuscules(nom_ref_inter) == "f")||(Minuscules(nom_ref_inter)=="o") ||(Minuscules(nom_ref_inter)=="0"))
                         {break;}
                      else if (nom_ref_inter.at(0) != 'N')
                        {cout << "\n *** erreur, la premiere lettre de la ref de noeuds "
                              << " doit etre N et non "<< nom_ref_inter.at(0)<< " !! *** "
                              << " \n ** cette ref n'est pas valide !! ** \n ";
                         nom_ref_inter = " "; // on re init
                        }
                      else
                        { if (plusieurs_maillages)
                            { cout << "\n nom du maillage associe ? ";
                              string nom_mail_associe;
                              nom_mail_associe= lect_chaine(); cout << " nom lu = "<< nom_mail_associe;
                              list_mail_secondaires.push_back(nom_mail_associe);
                            };
                          list_ref_secondaires.push_back(nom_ref_inter);
                        };
                    };
                   break;
               }
             case 3:  // type de degre de liberte
               { cout << "\n type d'un ddl de la condition lineaire: (ex: UX ou UY ou X1 ou V1 ...): ";
                 string enu_essai;
                 enu_essai= lect_chaine();cout << " valeur lue ="<<enu_essai;
                 if (ExisteEnum_ddl(enu_essai))
                  { if (Id_nom_ddl(enu_essai) != NU_DDL)
                      {enu = PremierDdlFamille(Id_nom_ddl(enu_essai));}
                    else {cout << "*** type de ddl non valide !! " << endl;};
                  }
                 else {cout << "*** type de ddl non valide !! " << endl;};
                 break;
               }
             case 4:  // valeur de la CLL
               { cout << "\n valeur de condition lineaire: (un reel): ";
                 val_condi=lect_double();cout << " valeur lue ="<< val_condi;
                 break;
                }
             case 5:  // coefficients de la CLL
               { cout << "\n avertissement: le nombre de coefficient doit etre identique a la dimension "
                      << " * (le nombre de ref secondaire + 1) , ici cf. vos precedentes reponses, il faut donc "
                      << "\n "<<dim<<" * ("<<list_ref_secondaires.size()<<"+ 1) = "
                      << (dim*(list_ref_secondaires.size()+1)) ;
                 int nb_val = (dim*(list_ref_secondaires.size()+1));
                 tab_coef_CLL.Change_taille(nb_val);
                 for (int i=1;i<= nb_val;i++)
                   { cout << "\n coefficient ("<<i<<")= ? ";cin >> tab_coef_CLL(i);
                     cout << " ( valeur lue : "<<tab_coef_CLL(i) << ") "<< endl;
                   };
                 std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// on vide cin
                 break;
               }
             case 6:  // condition relative
               { string reponse;
                 cout << "\n condition relative (rep: o ou n ) ? ";
                 reponse = lect_o_n(false);
                 cout << " (valeurs lue = "<<reponse<<") "<<endl;
                 if (Minuscules(reponse) == "o") { condition_relative=true;}
                 else {condition_relative = false;};
                 break;
               }
             case 7:  // temps mini
                { cout << "\n valeur du temps mini (un reel)  ? ";
                  temps_mini=lect_double();cout << " valeur lue ="<< temps_mini;
                  break;
                }
             case 8:  // temps maxi
                { cout << "\n valeur du temps maxi (un reel)  ? ";
                  temps_maxi=lect_double();cout << " valeur lue ="<< temps_maxi;
                  break;
                }
             case 9:  // def des courbes de charges
               { int nb_val = tab_coef_CLL.Taille();
                 tab_Co_charges.Change_taille(nb_val);
                 cout << "\n compte tenu de vos precedentes reponses il faut definir "<<nb_val<<" courbes de charge";
                 for (int i=1;i<=nb_val;i++)
                   {cout << "\n nom de la "<<i<<" ieme courbe de charge  ? ";
                    tab_Co_charges(i)= lect_chaine();cout << " nom lu = "<< tab_Co_charges(i);
                   };
                 break;
                }
             case 10:  // test si la CLL est recevable
               { int nb_val = (dim*(list_ref_secondaires.size()+1));
                 if (nom_ref == " ")
                   {cout <<"\n ** CLL incomplete, il manque le nom de la reference principale " << endl;}
                 else if (tab_coef_CLL.Taille()!=nb_val)
                   {cout <<"\n ** CLL incomplete, le nombre de coef n'est pas coherent avec le nb de "
                        <<"ref et la dimension " << endl;}
                 else if ((tab_Co_charges.Taille()!=0)&&(tab_Co_charges.Taille()!=nb_val))
                   {cout <<"\n ** CLL incomplete, le nombre de courbe de charge n'est pas coherent avec le nb de "
                        <<"ref et la dimension " << endl;}
                 else if (temps_mini > temps_maxi)
                   {cout <<"\n ** CLL complete mais inchoerente car le temps mini ("<<temps_mini<<") est "
                         << "superieur au temps maxi ("<<temps_maxi<<") "<< endl;}
                 else {cout << "\n a priori la condition est coherente et recevable "<<endl;};
                 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
 
    }
   else if (type_CLL == 3)
    {//On va proposer un menu
     string rep=" ";
     double temps_mini = - ConstMath::trespetit;
     double temps_maxi =  ConstMath::tresgrand;
     Enum_ddl enu=NU_DDL; // enuméré des ddl de la cll
     list <string> list_ref_secondaires; // liste des références secondaires
     list <string> list_mail_secondaires; // la liste des maillages associées à list_ref_secondaires
     bool condition_relative = false; // par défaut
     // tableau des choix possibles
     Tableau <string> tab_choix(7);
     tab_choix(1) =  "\n (0 ou f)  (fin)               ";
     tab_choix(2) =  "\n (1) reference principale de noeuds ";
     tab_choix(3) =  "\n (2) references secondaires de noeuds ";
     tab_choix(4) =  "\n (3) type de degre de liberte ";
     tab_choix(5) =  "\n (4) temps mini ";
     tab_choix(6) =  "\n (5) temps maxi ";
     tab_choix(7) =  "\n (6) test si la CLL est recevable ";
     string nom_ref="";
     ostringstream  flux;
 
     while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
      {
       try 
        { for (int i=1;i<=tab_choix.Taille();i++)
             cout << tab_choix(i);
          cout << "\n >>>  il faut obligatoirement definir a minima (1)+(2) <<< "
               << "\n      et de preference dans l'ordre indique ";
          cout << "\n rep : ";
          rep = lect_return_defaut(false,"f"); cout << " grandeur lue " << rep;
          if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
            // c'est à la sortie que ce fait l'écriture donc ici
            {sort << "\n";
             if ((nom_ref == " ")||(list_ref_secondaires.size()==0)
                )
               {cout <<"\n ** CLL incomplete, pas d'ecriture ";
                break;
               };
             if (plusieurs_maillages)
               { cout << "\n nom du maillage pour la ref principale ? ";
                 string nom_mail;
                 nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
                 sort << "nom_mail= "<< nom_mail << " ";
               };
             sort << nom_ref <<" enu= " << Nom_ddl(enu);
             // références secondaires éventuelles et / ou
             // temps mini et maxi éventuel
             if ( ((temps_mini != - ConstMath::trespetit)||(temps_maxi != ConstMath::tresgrand))
                 || (list_ref_secondaires.size() != 0))
              {sort << "\n";
               // les ref secondaires
               if (list_ref_secondaires.size() != 0)
                {list <string>::iterator ideb = list_ref_secondaires.begin();
                 list <string>::iterator idfin = list_ref_secondaires.end();
                 list <string>::iterator ill = list_mail_secondaires.begin();
                 sort << " refs_associe= ";
                 if (plusieurs_maillages)
                  {for (;ideb != idfin;ideb++, ill++)
                     sort << "nom_mail= "<< (*ill) << "  " << (*ideb) << " ";
                  }
                 else
                  {for (;ideb != idfin;ideb++, ill++)
                     sort << (*ideb) << " ";
                  };
                 sort << " fin_list_refs_associe_ ";
                };
               // encadrement en temps
               if (temps_mini != (- ConstMath::trespetit))
                sort << " TEMPS_MINI= "<< temps_mini<<" ";
               if (temps_maxi != ConstMath::tresgrand)
                sort << " TEMPS_MAXI= "<< temps_maxi<<" ";
               // le cas d'une condition relative ou pas
               if (condition_relative)
                 sort << " CONDITION_RELATIVE= 1 ";
              };
             // la condition
             sort << "\n  stricte_egalite_  " ;
             sort << endl << std::flush;
             break;
            };
          int num = ChangeEntier(rep);
          bool choix_valide=false;
          if ((num >= 0)&&(num<=6))
               { choix_valide=true; }
          else { cout << "\n Erreur on attendait un entier entre 0 et 6 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper f ou 0 pour arreter le programme";
                 choix_valide=false;
               }
          switch (num)
           { case 0:  // sortie
               { break;}
             case 1:  // reference principale de noeuds
               { cout << "\n nom de la ref de noeud pour l'application de la condition ? ";
                 nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
                 if (nom_ref.at(0) != 'N')
                  {cout << "\n *** erreur, la premiere lettre de la ref de noeuds "
                        << " doit etre N et non "<< nom_ref.at(0)<< " !! *** "
                        << " \n ** cette ref n'est pas valide !! ** \n ";
                   nom_ref = " "; // on re init
                   break;
                  };
                 break;
               }
             case 2:  // references secondaires de noeuds
               {  bool fin = false;
                  string nom_ref_inter=" ";
                  while (!fin)
                    { cout << "\n nom d'une ref de noeud secondaire ou f (ou 0 ou o) pour finir ? ";
                      nom_ref_inter= lect_chaine();cout << " nom lu = "<< nom_ref_inter;
                      if ((Minuscules(nom_ref_inter) == "f")||(Minuscules(nom_ref_inter)=="o") ||(Minuscules(nom_ref_inter)=="0"))
                         {break;}
                      else if (nom_ref_inter.at(0) != 'N')
                        {cout << "\n *** erreur, la premiere lettre de la ref de noeuds "
                              << " doit etre N et non "<< nom_ref_inter.at(0)<< " !! *** "
                              << " \n ** cette ref n'est pas valide !! ** \n ";
                         nom_ref_inter = " "; // on re init
                        }
                      else
                        { if (plusieurs_maillages)
                            { cout << "\n nom du maillage associe ? ";
                              string nom_mail_associe;
                              nom_mail_associe= lect_chaine(); cout << " nom lu = "<< nom_mail_associe;
                              list_mail_secondaires.push_back(nom_mail_associe);
                            };
                          list_ref_secondaires.push_back(nom_ref_inter);
                        };
                    };
                   break;
               }
             case 3:  // type de degre de liberte
               { cout << "\n type d'un ddl de la condition lineaire: (ex: UX ou UY ou X1 ou V1 ...): ";
                 string enu_essai;
                 enu_essai= lect_chaine();cout << " valeur lue ="<<enu_essai;
                 if (ExisteEnum_ddl(enu_essai))
                  { if (Id_nom_ddl(enu_essai) != NU_DDL)
                      {enu = PremierDdlFamille(Id_nom_ddl(enu_essai));}
                    else {cout << "*** type de ddl non valide !! " << endl;};
                  }
                 else {cout << "*** type de ddl non valide !! " << endl;};
                 break;
               }
             case 4:  // temps mini
                { cout << "\n valeur du temps mini (un reel)  ? ";
                  temps_mini=lect_double();cout << " valeur lue ="<< temps_mini;
                  break;
                }
             case 5:  // temps maxi
                { cout << "\n valeur du temps maxi (un reel)  ? ";
                  temps_maxi=lect_double();cout << " valeur lue ="<< temps_maxi;
                  break;
                }
             case 6:  // test si la CLL est recevable
               { if (nom_ref == " ")
                   {cout <<"\n ** CLL incomplete, il manque le nom de la reference principale " << endl;}
                 else if (list_ref_secondaires.size()==0)
                   {cout <<"\n ** CLL incomplete, il n'y a pas de liste secondaire "
                        <<"ref et la dimension " << endl;}
                 else if (temps_mini > temps_maxi)
                   {cout <<"\n ** CLL complete mais inchoerente car le temps mini ("<<temps_mini<<") est "
                         << "superieur au temps maxi ("<<temps_maxi<<") "<< endl;}
                 else {cout << "\n a priori la condition est coherente et recevable "<<endl;};
                 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
 
    }
   else if ((type_CLL == 1) && (dim == 1))
    { // cas particulier du 1D
      cout << "\n *** en 1D les CLL de projection ne sont pas possibles ";
    };
  };

    
// Construction de la condition : 1) mise en place d'une valeur imposée due à la condition linéaire 
// def des coefficients en fonction éventuellement des fonctions de charges et du  paramètre condition_relative
// NB: pour les conditions correspondant à une projection sur un plan ou une droite, il faut que la direction du plan
//     ou de la droite ait déjà été affecté auparavant
// !! la condition sur le ddl n'est pas imposée à ce niveau, par contre elle est stockée dans Condilineaire

Condilineaire& I_O_Condilineaire::ConstructionCondition
               (Tableau <Noeud *> & t_noe,Condilineaire& condi_actuelle)
{ // tout d'abord on évacue le cas de l'égalité stricte qui implique : rien n'a faire !
  if (stricte_egalite)
    return condi_actuelle; // condi_actuelle inchangée et ne doit servir à rien

  // on renseigne la condition
  Noeud * noe = t_noe(1); // le premier noeud est celui où on met la condition
  condi_actuelle.ChangeTabNoeud(t_noe); // on renseigne la condition
 
  // dimensionnement de la condition de retour, car val peut avoir été changé indépendamment
  condi_actuelle.Change_taille(val.Taille()); 
  Vecteur val_inter(val); // le vecteur qui contient les coeffs, est utiliser car dans le cas
                          // d'une def auto droite plan,  les coeffs sont récupéré donc modifié
  
  if (def_auto_par_rotation)
  	{ // cas d'une définition par rapport à une droite ou un plan
  	  // on récupère les valeurs qui ont été calculées au moment des projections
	    int dima = ParaGlob::Dimension();
     if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
	    // la valeur de la condition a déjà été calculée au moment de la projection
	    switch (dima)
        {case 2: // on tourne autour de z
           { val_inter(1) = -dr.VecDroite()(2);
             val_inter(2) = dr.VecDroite()(1);
             break;
           }
         case 3: 
           { val_inter = (pl.Vecplan()).Vect(); // pour simplifier
       	        break;
           }
        };
  	};
   
  // --- on met la condition ----- 
  if ((tab_co_charge.Taille() == 0) || def_auto_par_rotation)
     // cas sans fonction de charge, on applique la valeur complète
	 // dans le cas d'une projection plan ou droite, l'échelle est systématiquement = 1. (vérif à la lecture) 
	 // et on ne tient pas compte de la première fonction de charge 
  	 { condi_actuelle.BetaChange() = echelle * beta  ;}
  else
     // cas avec fonction de charge, que ce soit en relatif ou pas, on applique la valeur à t
     // (le coté relatif est a appliqué au niveau des ddl des noeuds, qui sont des valeurs issues
     //  du calcul d'équilibre, et non au niveau des valeurs fixés qui elles peuvent être déterminées
     // à l'avance, donc pour ces dernières aucun intérêts de faire du relatif, par contre pour les ddl
     // des noeuds, là le coté relatif est important car il permet d'ajouter à un ddl dont la valeur
     // est issue du précédent calcul, donc pas connue à l'avance)
  	  { condi_actuelle.BetaChange() = echelle * beta  *  fctch(1) ;};

  // --- maintenant on s'occupe des pointeurs et des coefficients
  double valfinalSurddlAbloquer = 0; // on calcul en même temps la valeur à imposer 
  Tableau <Enum_ddl > t_enu(val.Taille()); // tableau des identificateur de ddl de la CLL
  
  // $-$ NB:  on traite différemment selon qu'il s'agisse de conditions linéaires entre position ou déplacement,
  // $-$  ou sur des autres ddl, because, le cas déplacement-position est un peu particulier mais cependant
  // $-$  globalement c'est très ressemblant
  
  if (Meme_famille(enu,X1) || Meme_famille(enu,UX))
    { // le premier indice correspondra a la direction bloquee, il faut s'assurer qu'il ne 
      // soit pas nul et qu'il ne correspond pas a une direction deja bloquee par les conditions
      // limites de depart
      // on boucle sur la dim pour trouver le coef le plus grand correspondant a une direction
      // non bloquee
      int dima = ParaGlob::Dimension();
      if(ParaGlob::AxiSymetrie())
        // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
        // dimension-1 coordonnées donc on décrémente
        dima--;
      int iti=0;int indi = 0; double maxi = ConstMath::petit;
      int posi = Id_nom_ddl("X1") -1; // position du ddl X1
      // on cherche le numero de ddl libre qui est associé à la valeur maxi différente de 0
      if ((!def_auto_par_rotation)&&(tab_co_charge.Taille() != 0))
        // dans le cas normal, avec fonction de charge, on tiens compte de ces fonctions
        {for (iti=1; iti<= dima; iti++)
          { if (!noe->Ddl_fixe(Enum_ddl(posi+iti))) // cas d'un ddl libre
             {double coef_reel = Dabs(val_inter(iti) * fctch(iti+1));
              if (coef_reel > maxi) // cas d'une valeur de coefficient non nul
                { maxi = coef_reel;
                  indi = iti;
                 };
             }
          };
        }
      else
        // autres cas: cas des projections ou cas sans fonction de charge
        {for (iti=1; iti<= dima; iti++)
          { if (!noe->Ddl_fixe(Enum_ddl(posi+iti))) // cas d'un ddl libre
              if (Dabs(val_inter(iti)) > maxi) // cas d'une valeur de coefficient non nul
                { maxi = Dabs(val_inter(iti)); 
                  indi = iti;
                 };
          };
        };
      if (indi ==0)
         { // cas ou soit les dima ddl sont bloque, soit le vecteur normal = 0
           cout << "\n erreur dans une condition limite lineaire , on ne peut pas imposer de condition lineaire" 
                << " car soit les  ddl de deplacement du noeud principal de la condition sont deja tous bloque, "
                << " soit le vecteur condition (les coeffs) est nul \n";
           noe->Affiche();
           cout << "\n les coeff : " ; val_inter.Affiche();
           cout << "Condilineaire& I_O_Condilineaire::ConstructionCondition(.." << endl;
           Sortie (1);
          };
      // on indique que la nouvelle direction "indi" est bloque, ceci permet
      // pour une autre condition, de ne pas reprendre cette direction
      // --> ce marquage est effacer apres resolution, par la fonction efface blocage
      Enum_ddl leEnuAChanger = Enum_ddl(posi+indi);  // le enu du ddl_k de la condition
      noe->Change_fixe(leEnuAChanger,true);
      condi_actuelle.ChangeIddl() = indi; // on enregistre la position 
      // on avance dans la constitution de  valfinalSurddlAbloquer
      double unsurcoef1 = 1./val_inter(condi_actuelle.Iddl()); // correspond à 1/alph_k de la condition 
      if ((!def_auto_par_rotation)&&(tab_co_charge.Taille() != 0))
         // dans le cas normal, avec fonction de charge, on tiens compte de ces fonctions
         unsurcoef1 = 1./fctch(indi+1);
      // constitution de la condition lineaire
      int itab = 0.; // définit à l'extérieur car va continuer à s'incrémenter sur la deuxième boucle qui suit
      for (itab=1;itab<= dima;itab++)
        { // condi_actuelle.val_inter(1) correspond à coef(indi), puis les autres suivent
          double coefindi =0.;
          if (!def_auto_par_rotation)
    	     { if (tab_co_charge.Taille() == 0)
    	    	         { coefindi = val(indi) ; }
    	       else   { coefindi = val(indi) * fctch(indi+1) ;};
    	     }
    	    else // dans le cas plan droite les coef sont déjà intégrés
    	     {coefindi = val_inter(indi);};
         t_enu(itab)= Enum_ddl(posi+indi); // sauvegarde de l'enum associé
         condi_actuelle.Valchange()(itab) = echelle * coefindi;  // pour le coefficient
//--------------
         // suite constitution de  valfinalSurddlAbloquer :
         if (itab == 1) 
           // correspond à beta/alpha_k 	  
           { valfinalSurddlAbloquer = condi_actuelle.Beta() * unsurcoef1; }
         else 
           // correspond à -alph_i/alph_k * U_i	  
           // il faut distinguer les  cas suivant que c'est une condition linéaire entre Xi ou entre Ui
           // et que l'on est en relatif ou pas 
           { if (condition_relative)
                // dans le cas d'une projection, par construction (vérif à la lecture), la condition  n'est pas relative !!
              { // que ce soit en Xi ou en Ui, comme on est en relatif il  faut considérer l'accroissement
                valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 
// **** a priori une erreur :  23 sep 2014  * (noe->Valeur_tdt(Enum_ddl(posi+itab)) -  noe->Valeur_t(Enum_ddl(posi+itab)) ) ;
                                 * (noe->Valeur_tdt(Enum_ddl(posi+indi)) -  noe->Valeur_t(Enum_ddl(posi+indi)) ) ;
              }
             else 
                   // donc ici il s'agit d'une condition absolue
              { if (Meme_famille(enu,X1))
                  // cas d'une CLL entre Xi on y accède directement
// **** a priori une erreur :  23 sep 2014      { valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 * noe->Valeur_tdt(Enum_ddl(posi+itab)) ;}
                    { valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 * noe->Valeur_tdt(Enum_ddl(posi+indi)) ;
////--debug
//cout << "\n debug I_O_Condilineaire::ConstructionCondition noe_val= " << noe->Valeur_tdt(Enum_ddl(posi+indi))
//     << " valfinalSurddlAbloquer= " << valfinalSurddlAbloquer << " coefindi= " << coefindi << " unsurcoef1= " << unsurcoef1
//     << "Enum_ddl(posi+indi)= " << Enum_ddl(posi+indi) << endl ;
////--fin debug
                    }
                  else
                  // cas d'une CLL entre Ui, il faut donc prendre en compte le delta Xi entre 0 et tdt
                    { valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 
// **** a priori une erreur :  23 sep 2014     * (noe->Valeur_tdt(Enum_ddl(posi+itab)) -  noe->Valeur_0(Enum_ddl(posi+itab)) ) ;
                                      * (noe->Valeur_tdt(Enum_ddl(posi+indi)) -  noe->Valeur_0(Enum_ddl(posi+indi)) ) ;
                    };
              };
           };
//-------------------
         indi ++;
         if (indi > dima) indi = 1;  // on fait une rotation circulaire
		      };
      // cas des noeuds des références secondaires
      int nbnsecondaire = refs_associe.Taille(); 
      for (int nn=2; nn<=nbnsecondaire+1; nn++) // le premier noeud secondaire est pour nn=2
        { Noeud & noese = *(t_noe(nn));
          // récup du pointeur d'assemblage  -1
          #ifdef MISE_AU_POINT	 	 
          if (def_auto_par_rotation)
            { cout << "\nErreur : on ne doit pas avoir de ref secondaire avec la def auto "
                   <<  '\n'
                   << "Condilineaire& I_O_Condilineaire::ConstructionCondition(.. 3\n";
              Sortie(1);
            };
          #endif
          for (int ia=1;ia<= dima;ia++,itab++)
            { double coefitab =0.;
              if (tab_co_charge.Taille() == 0)
    	    	           { coefitab = val_inter(itab) ; }
    	         else   { coefitab = val_inter(itab) * fctch(itab+1) ;};
              t_enu(itab)= Enum_ddl(posi+ia); // sauvegarde de l'enum associé 
    	         condi_actuelle.Valchange()(itab) = echelle * coefitab;  // pour le coefficient
              // suite constitution de  valfinalSurddlAbloquer : correspond à -alph_i/alph_k * U_i 
              // il faut distinguer les  cas suivant que c'est une condition linéaire entre Xi ou entre Ui
              // et que l'on est en relatif ou pas 
              if (condition_relative)
				          // dans le cas d'une projection, par construction (vérif à la lecture), la condition  n'est pas relative !!
              	 { // que ce soit en Xi ou en Ui, comme on est en relatif il  faut considérer l'accroissement
              	   valfinalSurddlAbloquer -=  echelle * coefitab * unsurcoef1 
              	             * (noese.Valeur_tdt(Enum_ddl(posi+ia)) -  noese.Valeur_t(Enum_ddl(posi+ia)) ) ;
                }
              else 
                // donc ici il s'agit d'une condition absolue
                { if (Meme_famille(enu,X1))
                    // cas d'une CLL entre Xi on y accède directement
              	     { valfinalSurddlAbloquer -=  echelle * coefitab * unsurcoef1 * noese.Valeur_tdt(Enum_ddl(posi+ia)) ;}
                  else
                    // cas d'une CLL entre Ui, il faut donc prendre en compte le delta Xi entre 0 et tdt
              	     { valfinalSurddlAbloquer -=  echelle * coefitab * unsurcoef1 
              	                * (noese.Valeur_tdt(Enum_ddl(posi+ia)) -  noese.Valeur_0(Enum_ddl(posi+ia)) ) ;
              		
              	     };
                };
		        		};
        };
      // on met à jour le tableau d'enum de la condition
      condi_actuelle.Change_tab_enum(t_enu);
      
      // on finit le calcul de la valeur du ddl imposé
      if (condition_relative)
      	{ // que ce soit en Xi ou en Ui, comme on est en relatif 
          // comme le ddl au niveau du noeud est Xi, il faut le rajouter
      	  valfinalSurddlAbloquer +=  noe->Valeur_t(leEnuAChanger); 
      	}
      else 
        // donc ici il s'agit d'une condition absolue
        { if (Meme_famille(enu,X1))
            // cas d'une CLL entre Xi on a rien à faire, valfinalSurddlAbloquer est directement = à 
            // la valeur a imposer
      	    { }
          else
            // cas d'une CLL entre Ui, il faut donc prendre en compte le delta Xi entre 0 et tdt
            // comme le ddl au niveau du noeud est Xi, il faut le rajouter
      	    { valfinalSurddlAbloquer +=  noe->Valeur_0(leEnuAChanger);};
        };
       
      // et maintenant on sauvegarde la valeur a bloquer sur le noeud dans la condition linéaire
      // cette condition correspondra au ddl_i' dans le nouveau repèrere qui recevra  la condition bloqué
      // en fait ddl_i sera la seule modification de ddl due à la mise en place de la CLL
      // !!! par contre ce changement de valeur n'est pas à effectuer dans le cas des projections,
      // car dans ce cas, d'une part valfinalSurddlAbloquer doit toujours être à 0 et  d'autre part
      // la valeur des coordonnées est fixées lors de la projection et non ici 	  
      if (!def_auto_par_rotation)
       { condi_actuelle.ChangeUk_impose(valfinalSurddlAbloquer);}
      else 
       { condi_actuelle.ChangeUk_impose(ConstMath::tresgrand);};
/*
		on met en place la condition limite sur le ddl ddl_i du noeud principal
      // qui correspond au ddl_i' dans le nouveau repèrere qui recevra  la condition bloqué
      // en fait ddl_i sera la seule modification de ddl due à la mise en place de la CLL
	  // !!! par contre ce changement de valeur n'est pas à effectuer dans le cas des projections,
	  // car dans ce cas, d'une part valfinalSurddlAbloquer doit toujours être à 0 et  d'autre part
	  // la valeur des coordonnées est fixées lors de la projection et non ici 
      noe->Change_val_tdt(leEnuAChanger,valfinalSurddlAbloquer);  
*/		
		
		
    } // -- fin du cas d'une condition linéaire sur un déplacement ou position
  else  
    { // -- cas d'une famille autre que déplacement ou position
      // (en fait pas de diff mais je préfère pour l'instant séparer les deux )
      // le premier indice correspondra a la direction bloquee, il faut s'assurer qu'il ne 
      // soit pas nul et qu'il ne correspond pas a une direction deja bloquee par les conditions
      // limites de depart
      // on boucle pour trouver le coef le plus grand correspondant a une direction non bloquee
      int iti=0;int indi = 0; double maxi = ConstMath::petit;
      int posi = enu -1; // position du premier ddl de la famille
      // on cherche le nb de ddl libre qui est associé à la valeur maxi différente de 0 
      for (iti=1; iti<= nbddlfamille; iti++)
        { if (!noe->Ddl_noeud_tdt(Enum_ddl(posi+iti)).Fixe()) // cas d'un ddl libre
            if (Dabs(val(iti)) > maxi) // cas d'une valeur de coefficient non nul
              { maxi = Dabs(val(iti)); 
                indi = iti;
               };
        };
      if (indi ==0)
         { // cas ou soit les dima ddl sont bloque, soit le vecteur normal = 0
           cout << "\n erreur dans une condition limite lineaire , " 
                << " soit les ddl de la famille " << Nom_ddl(enu) << " du noeud principal  sont deja tous bloque, "
                << " soit le vecteur condition (les coeffs) est entierement nul \n";
           noe->Affiche();
           cout << "\n les coeff : " ; condi_actuelle.Valchange().Affiche();
           cout << "Condilineaire& I_O_Condilineaire::ConstructionCondition(.." << endl;
           Sortie (1);
         };
      // on indique que la nouvelle direction "indi" est bloque, ceci permet
      // pour une autre condition, de ne pas reprendre cette direction
      // --> ce marquage est effacer apres resolution, par la fonction efface blocage
      Enum_ddl leEnuAChanger = Enum_ddl(posi+indi);  // le enu du ddl_k de la condition  
      noe->Change_fixe(leEnuAChanger,true);
      condi_actuelle.ChangeIddl() = indi; // on enregistre la position 
      // on avance dans la constitution de  valfinalSurddlAbloquer
      double unsurcoef1 = 1./val_inter(condi_actuelle.Iddl()); // correspond à 1/alph_k de la condition 
      // constitution de la condition lineaire
      int itab = 0.; // définit à l'extérieur car va continuer à s'incrémenter sur deuxième boucle qui suit
      for (itab=1;itab<= nbddlfamille;itab++)
        { // condi_actuelle.val(1) correspond à coeff(indi), puis les autres suivent
          double coefindi =0.;
    	    if (tab_co_charge.Taille() == 0)
    	    	   { coefindi = val(indi) ; }
    	    else { coefindi = val(indi) * fctch(indi+1) ;};
         t_enu(itab)= Enum_ddl(posi+indi); // sauvegarde de l'enum associé
    	    condi_actuelle.Valchange()(itab) = echelle * coefindi;  // pour le coefficient
         //--------------
         // suite constitution de  valfinalSurddlAbloquer : 
         if (itab == 1) 
         // correspond à beta/alpha_k 	  
           { valfinalSurddlAbloquer = condi_actuelle.Beta() * unsurcoef1;}
         else 
         // correspond à -alph_i/alph_k * U_i	  
         // il faut distinguer les  cas suivant que c'est une condition linéaire entre Xi ou entre Ui
         // et que l'on est en relatif ou pas 
           { if (condition_relative)
                  // dans le cas d'une projection, par construction (vérif à la lecture), la condition  n'est pas relative !!  
               { // que ce soit en Xi ou en Ui, comme on est en relatif il  faut considérer l'accroissement
                 valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 
// **** a priori une erreur :  23 sep 2014       * (noe->Valeur_tdt(Enum_ddl(posi+itab)) -  noe->Valeur_t(Enum_ddl(posi+itab)) ) ;
                        * (noe->Valeur_tdt(Enum_ddl(posi+indi)) -  noe->Valeur_t(Enum_ddl(posi+indi)) ) ;
               }
             else
               // donc ici il s'agit d'une condition absolue on y accède directement
// **** a priori une erreur :  23 sep 2014   { valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 * noe->Valeur_tdt(Enum_ddl(posi+itab)) ;
               { valfinalSurddlAbloquer -=  echelle * coefindi * unsurcoef1 * noe->Valeur_tdt(Enum_ddl(posi+indi)) ;
               };
           }
         //-------------------
         indi ++;      
         if (indi > nbddlfamille) indi = 1;  // on fait une rotation circulaire
		      };
      // cas des noeuds des références secondaires
      int nbnsecondaire = refs_associe.Taille(); 
      for (int nn=2; nn<=nbnsecondaire+1; nn++) // le premier noeud secondaire est pour nn=2
        { Noeud & noese = *(t_noe(nn));
          for (int ia=1;ia<= nbddlfamille;ia++,itab++)
            {double coefitab =0.;
    	        if (tab_co_charge.Taille() == 0)
							             { coefitab = val(itab) ; }
    	        else   { coefitab = val(itab) * fctch(itab+1) ;};
    	        condi_actuelle.Valchange()(itab) = echelle * coefitab;  // pour le coefficient
             t_enu(itab)= Enum_ddl(posi+ia); // sauvegarde de l'enum associé
             // suite constitution de  valfinalSurddlAbloquer : correspond à -alph_i/alph_k * U_i  
             // il faut distinguer les  cas suivant que c'est une condition linéaire entre Xi ou entre Ui
             // et que l'on est en relatif ou pas 
             if (condition_relative)
              	{ // comme on est en relatif il  faut considérer l'accroissement
              	  valfinalSurddlAbloquer -=  echelle * coefitab * unsurcoef1 
              	             * (noese.Valeur_tdt(Enum_ddl(posi+ia)) -  noese.Valeur_t(Enum_ddl(posi+ia)) ) ;
              	}
             else
               // donc ici il s'agit d'une condition absolue on y accède directement
               { valfinalSurddlAbloquer -=  echelle * coefitab * unsurcoef1 * noese.Valeur_tdt(Enum_ddl(posi+ia)) ;
               };
            };
        };
      // on met à jour le tableau d'enum de la condition
      condi_actuelle.Change_tab_enum(t_enu);  
      
      // on finit le calcul de la valeur du ddl imposé
      if (condition_relative)
      	{ // comme on est en relatif il faut rajouter la valeur à t
      	  valfinalSurddlAbloquer +=  noe->Valeur_t(leEnuAChanger); 
      	};
      // sinon il n'y a rien à faire,  valfinalSurddlAbloquer est directement = à 
      // la valeur a imposer
       
      // et maintenant on sauvegarde la valeur a bloquer sur le noeud dans la condition linéaire
      // qui correspond au ddl_i' dans le nouveau repèrere qui recevra  la condition bloqué
      // en fait ddl_i sera la seul modification de ddl due à la mise en place de la CLL
		    condi_actuelle.ChangeUk_impose(valfinalSurddlAbloquer);

/*
      // et maintenant on met en place la condition limite sur le ddl ddl_i du noeud principal
      // qui correspond au ddl_i' dans le nouveau repèrere qui recevra  la condition bloqué
      // en fait ddl_i sera la seul modification de ddl due à la mise en place de la CLL
      noe->Change_val_tdt(leEnuAChanger,valfinalSurddlAbloquer);  
*/		
		
    };  // -- fin du cas d'une condition linéaire une famille quelconque autre que position et déplacement
      
  // retour
//  //--- debug
//  cout << "\n la condition lineaire : I_O_Condli ";
//  this->Affiche();
//  cout << "\n la condition resultat ";
//  condi_actuelle.Affiche();
//  // fin debug --- 
 
  return condi_actuelle;	
};

// initialisation des grandeurs de travail
void I_O_Condilineaire::Initialisation_condil()
	{Tableau<Enum_ddl> tab_enu = TableauTypeDdlmobileAvecAxi(enu);
  nbddlfamille = tab_enu.Taille();
  if (!stricte_egalite) // dans le cas stricte_egalité il n'y a pas de coef
    {// on vérifie l'adéquation des dimensions
     int ndimvec = nbddlfamille * (1+ refs_associe.Taille()); // nombre total de ddl concerné
     if (ndimvec != val.Taille())
     	{ cout << "\n erreur de dimension: le nombre de coefficient de la condition limite = " << val.Taille()
     	       << " est different du nombre de ddl de la famille concernee " << nbddlfamille << " fois le nombre de noeud "
     	       << " c'est-a-dire (1 + le nombre de ref secondaire) = " << (1+ refs_associe.Taille()) << " ce qui fait: " 
     	       << ndimvec << endl;
     	  Sortie(1);     
     	};
    };
	};  

// definition du noeud: centre rotation
void I_O_Condilineaire::ChangeCentreNoeudRotation( Noeud* noe) 
  {centre_noeud = noe;
   int dima = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;

   switch (dima)
   	{ case 2: switch(type_centre)
   	          	{case 2 : dr.Change_ptref(noe->Coord0()); break;
   	          	 case 3 : dr.Change_ptref(noe->Coord2()); break;
   	          	}
   	          break; 
   	  case 3: switch(type_centre)
   	          	{case 2 : pl.Change_ptref(noe->Coord0()); break;
   	          	 case 3 : pl.Change_ptref(noe->Coord2()); break;
   	          	}
   	          break; 
   	};
   // dans le cas ou type_centre = 1, on ne fait rien, donc le centre actuellement enregistré est maintenu	
   };

// indique si le blocage qui existe déjà sur les noeuds à projeter, est cohérent
// avec la projection:
// typiquement si la direction de blocage est normale au plan de rotation
// ramène true si on peut concerver la condition de projection
// en entrée: indi qui donne la direction déjà bloquée
bool I_O_Condilineaire::Coherence_condi_PlanDroite(int indi)const
 { bool retour = false;
   int dima = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   switch (dima)
      { case 2:
          { const Coordonnee& dro = dr.VecDroite();
            if (Dabs(dro(indi)) < ConstMath::pasmalpetit)
                retour = true;
            break;
          }
        case 3:
          { const Coordonnee& N = pl.Vecplan();
            if (Dabs(N(indi)) < ConstMath::pasmalpetit)
                retour = true;
            break;
          }
        default:
        break; // pour les autres dimensions on ne fait rien
      };
   // retour
   return retour;
  };

// définition de la direction actuelle ou normale pour plan droite
void I_O_Condilineaire::ActualiseDirectionPlanDroite()
  {// exécution en fonction de la présence de fonction de charge ou non
   Coordonnee dir(val.Coordo()); // val doit avoir la dimension du pb
   int dima = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   if (tab_co_charge.Taille() != 0)
    	{ for (int i=1;i<=dima;i++)
    	    dir(i) *= fctch(i+1) ;
    	 };
   switch (dima)
   	{ case 2:  dr.Change_vect(dir); break; // on met à jour la direction
   	  case 3: pl.Change_normal(dir); break; // on met à jour la direction
   	};
  };

// projection (normale) du point M sur le plan ou droite, ramène le point M à la place du
// projeté,  et calcul de la condition linéaire correspondant à la projection
Coordonnee& I_O_Condilineaire::ProjectionSurPlanDroite_et_calValCondiLin(Coordonnee& M )
  {int dima = ParaGlob::Dimension();
   if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   switch (dima)
     { case 2:{ M = dr.Projete(M);
                beta  = -dr.VecDroite()(2)*M(1)+dr.VecDroite()(1)*M(2);
                break;
              }
       case 3:{ M = pl.Projete(M);
                beta = pl.Vecplan() * M ;
                break;
              }
       default: break; // pour les autres dimensions on ne fait rien
     };
   // retour
   return M;	
  };

		 
// surcharge de l'operateur de lecture typée
istream & operator >> (istream & entree, I_O_Condilineaire & cLL)
  { // vérification du type
    string type;
    entree >> type;
    if (type != "I_O_Condilineaire___ref_princ=") 
      {cout << "\n erreur en lecture d'une condition lineaire "
            << "\n operator >> (istream & entree, I_O_Condilineaire & cLL) "; 
       Sortie (1);
       return entree;
      }
    // lecture d'un nom de maillage éventuel
    bool existe_nom_maillage; entree >> existe_nom_maillage;
    string nom;
    if (existe_nom_maillage) 
       { entree >> nom; 
         if (cLL.nom_maillage == NULL) 
            {cLL.nom_maillage = new string(nom);}
         else 
            {*(cLL.nom_maillage) = nom;};
       };
    // maintenant la référence principale
    entree  >> cLL.refe ;
    // les références associés
    int tai=0;
    entree >> nom >> tai;
    if (tai != 0)
      {cLL.refs_associe.Change_taille(tai);
       if (cLL.nom_maillage != NULL)
       	{cLL.nom_mail_associe.Change_taille(tai);
         for (int i=1;i<=tai;i++)
             {entree >> cLL.nom_mail_associe(i) >> cLL.refs_associe(i); };
       	}
       else   
       	{for (int i=1;i<=tai;i++)
             {entree >> cLL.refs_associe(i); };
       	};
      };
    entree >> nom >> cLL.enu ;
    entree >> nom >> cLL.def_auto_par_rotation;
    entree >> nom >> cLL.stricte_egalite;
    int dima = ParaGlob::Dimension();
    if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   
    if (cLL.stricte_egalite)
     {   }
    else
     {if (cLL.def_auto_par_rotation)
        {entree >> nom >> cLL.type_centre;
         if (cLL.type_centre == 1)
          { entree >> nom;
            Coordonnee B; 
            entree >> nom >> B; 
            if (dima == 2)
              {cLL.dr.Change_ptref(B) ;}
            else 
              {cLL.pl.Change_ptref(B) ;};
           }
         else if  ((cLL.type_centre == 2) || (cLL.type_centre == 3)) 
          { entree >> nom >> cLL.mailEtNumCentreNoeud ;} 
         Coordonnee V; 
         entree >> nom >> V >> nom >> cLL.val;  
         if (dima == 2)
           {cLL.dr.Change_vect(V);}
         else // cas dimension 3
           {cLL.pl.Change_normal(V);};
        }
      else
        { entree >> nom >> cLL.beta  >> nom >> cLL.val;};
      entree >> nom >> cLL.condition_relative
             >> nom >> cLL.echelle;
      entree >> nom >> cLL.tab_co_charge;
     };
   
//    if (!cLL.def_auto_par_rotation)
//      { entree >> nom >> cLL.beta  >> nom >> cLL.val;}
//    else
//      {entree >> nom >> cLL.type_centre;
//       if (cLL.type_centre == 1)
//        { entree >> nom;
//          Coordonnee B; 
//          entree >> nom >> B; 
//          if (ParaGlob::Dimension() == 2) 
//            {cLL.dr.Change_ptref(B) ;}
//          else 
//            {cLL.pl.Change_ptref(B) ;};
//         }
//       else if  ((cLL.type_centre == 2) || (cLL.type_centre == 3)) 
//        { entree >> nom >> cLL.mailEtNumCentreNoeud ;} 
//       Coordonnee V; 
//       entree >> nom >> V >> nom >> cLL.val;  
//       if (ParaGlob::Dimension() == 2)
//         {cLL.dr.Change_vect(V);}
//       else // cas dimension 3
//         {cLL.pl.Change_normal(V);};
//      };
   
    entree >> nom >> cLL.t_min >> nom >>  cLL.t_max
           >> nom >> cLL.precedent;
   
    return entree;
  };
  
// surcharge de l'operateur d'ecriture typée
ostream & operator << ( ostream & sort,const  I_O_Condilineaire & cLL)
  { // tout d'abord un indicateur donnant le type 
    sort << " I_O_Condilineaire___ref_princ= " ;
    // puis le maillage éventuelle
    if (cLL.nom_maillage == NULL) 
       {sort << false << " ";} 
    else 
       {sort << true << " " << *(cLL.nom_maillage) << " ";};
    // maintenant la référence principale
    sort  << cLL.refe << " ";
    // les références associés
    if (cLL.refs_associe.Taille() != 0)
       {int tai = cLL.refs_associe.Taille();
        sort << " ref_associe___taille= " << tai << " ";
        for (int i=1;i<=tai;i++)
          if (cLL.nom_maillage != NULL) 
             {sort << cLL.nom_mail_associe(i) << " " << cLL.refs_associe(i) << " ";}
          else   
             {sort  << cLL.refs_associe(i) << " ";}
       };
    sort << "\n type_ddl= " << Nom_ddl(cLL.enu) ;
    sort <<  " def_auto_par_rotation= " << cLL.def_auto_par_rotation;
    sort <<  " stricte_egalite= " << cLL.stricte_egalite;
    int dima = ParaGlob::Dimension();
    if(ParaGlob::AxiSymetrie())
      // cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
      // dimension-1 coordonnées donc on décrémente
      dima--;
   
    if (cLL.stricte_egalite)
     {   }
    else
     {if (cLL.def_auto_par_rotation)
        {sort << " type_centre= " << cLL.type_centre;
         if (cLL.type_centre == 1)
          { sort << " centre_fixe= " ;
            if (dima == 2) {sort << cLL.dr.PointDroite() << " " ;}
            else {sort << cLL.pl.PointPlan() << " " ;};
           }
         else if  (cLL.type_centre == 2) 
          { sort << " centre_noeud_t0= " << cLL.mailEtNumCentreNoeud << " ";} 
         else if  (cLL.type_centre == 3) 
          { sort << " centre_noeud_t= " << cLL.mailEtNumCentreNoeud << " ";};
         if (dima == 2)
           {sort << " dir_droite_now= " << cLL.dr.VecDroite() <<  " dir_droite0= " << cLL.val;}
         else // cas dimension 3
           {sort << " normal_plan_now= " << cLL.pl.Vecplan() << " normal_plan0= " << cLL.val;}
        }
      else
        { sort << " val_condi= " << cLL.beta << " coefficients= " << cLL.val;};
      sort << "  condition_relative= " << cLL.condition_relative << " "
           << " echelle= " << cLL.echelle;
      sort << "\n courbe_charge= " << cLL.tab_co_charge;
     };
   
   
//    if (!cLL.def_auto_par_rotation)
//      { sort << " val_condi= " << cLL.beta << " coefficients= " << cLL.val;}
//    else
//      {sort << " type_centre= " << cLL.type_centre;
//       if (cLL.type_centre == 1)
//        { sort << " centre_fixe= " ;
//          if (ParaGlob::Dimension() == 2) {sort << cLL.dr.PointDroite() << " " ;}
//          else {sort << cLL.pl.PointPlan() << " " ;};
//         }
//       else if  (cLL.type_centre == 2) 
//        { sort << " centre_noeud_t0= " << cLL.mailEtNumCentreNoeud << " ";} 
//       else if  (cLL.type_centre == 3) 
//        { sort << " centre_noeud_t= " << cLL.mailEtNumCentreNoeud << " ";};
//       if (ParaGlob::Dimension() == 2)
//         {sort << " dir_droite_now= " << cLL.dr.VecDroite() <<  " dir_droite0= " << cLL.val;}
//       else // cas dimension 3
//         {sort << " normal_plan_now= " << cLL.pl.Vecplan() << " normal_plan0= " << cLL.val;}
//      };
   
    sort << "\n tmin= " << cLL.t_min << " tmax= " << cLL.t_max
         << " prec " << cLL.precedent;

    return sort;      
  };