// 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-2021 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 "LesContacts.h"
#include <vector>
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "CharUtil.h"

#include "Enum_TypeQuelconque.h"
#include "TypeQuelconqueParticulier.h"



// récupération des ddl ou des grandeurs actives de tdt vers t 
void LesContacts::TdtversT()
	{  LaLIST <ElContact>::iterator il,ilfin=listContact.end();
    for (il=listContact.begin();il != ilfin; il++)
          (*il).TdtversT();
    // on nettoie les indicateurs transitoires
    listContact_nouveau_tatdt.clear();
    listContact_efface_tatdt.clear();
	};

// actualisation des ddl et des grandeurs actives de t vers tdt      
void LesContacts::TversTdt()
	{  // on essaie de mettre la situation de contact comme elle était à t
    // a) on supprime les nouveaux contacts
    {LaLIST <LaLIST <ElContact>::iterator>::iterator al,alfin=listContact_nouveau_tatdt.end();
     for (al=listContact_nouveau_tatdt.begin();al != alfin; al++)
       { ElContact& elc = (*(*al));
         Noeud* no = elc.Esclave();
         int n_noee = no->Num_noeud();
         int num_mail_noe_esclave = no->Num_Mail();
         #ifdef MISE_AU_POINT
         if (tesN_encontact(num_mail_noe_esclave).find(no)
                 == tesN_encontact(num_mail_noe_esclave).end() )
            { cout << "\n*** Erreur : on ne trouve pas la liste d'element en contact avec le noeud esclave "
                   << n_noee << " du maillage " << num_mail_noe_esclave
                   << " la suite n'est pas possible "
                   << " LesContacts::TversTdt(.. \n";
              Sortie(1);
            };
         #endif
         LaLIST < LaLIST<ElContact>::iterator >  & list_tesN
                            = tesN_encontact(num_mail_noe_esclave)[no];
         list_tesN.remove(*al);
//         tesN_encontact(num_mail_noe_esclave)(n_noee).remove(*al);
         if (elc.Actif()) //a priori les nouveaux contacts étaient actif
            nb_contact_actif--; // mais on ne sait jamais
         listContact.erase(*al);
// cout << "\n debug toto ";
        };
    };
    // b) on rajoute les contacts supprimés
    {LaLIST <ElContact>::iterator al,alfin=listContact_efface_tatdt.end();
     for (al=listContact_efface_tatdt.begin();al != alfin; al++)
       { ElContact& elc = (*al);
         Noeud* no = elc.Esclave();
         int n_noee = no->Num_noeud();
         int num_mail_noe_esclave = no->Num_Mail();
         listContact.push_front(*al);
         // on met à jour le tableau tesN_encontact
         #ifdef MISE_AU_POINT
           if (tesN_encontact(num_mail_noe_esclave).find(no)
                 == tesN_encontact(num_mail_noe_esclave).end() )
            { cout << "\n*** Erreur : on ne trouve pas la liste d'element en contact avec le noeud esclave "
                   << n_noee << " du maillage " << num_mail_noe_esclave
                   << " la suite n'est pas possible "
                   << " LesContacts::TversTdt(.. \n";
              Sortie(1);
            };
         #endif
         tesN_encontact(num_mail_noe_esclave)[no].push_front(listContact.begin());
         if ((*al).Actif()) // si l'élément supprimé était actif on remet à jour
            nb_contact_actif++;
        };
    };
    // c) on nettoie les indicateurs transitoires
    listContact_nouveau_tatdt.clear();
    listContact_efface_tatdt.clear();
    // d) on revient à t pour les éléments en contact
    {LaLIST <ElContact>::iterator il,ilfin=listContact.end();
     for (il=listContact.begin();il != ilfin; il++)
          (*il).TversTdt();
    };
	};
	 
		
// cas d'une méthode avec pénalisation: calcul éventuel d'un pas de temps idéal, 
// si oui retour de la valeur delta_t proposé
// sinon dans tous les autres cas retour de 0.
// le calcul se fait en fonction du pas de temps courant et de la pénétration
// donc nécessite que le contact ait déjà été étudié 
double LesContacts::Pas_de_temps_ideal()const
{ double delta_optimal=ConstMath::tresgrand;
  // on passe en revue tous les contacts
  LaLIST <ElContact>::const_iterator il,ilfin=listContact.end();
	 for (il=listContact.begin();il != ilfin; il++)
	   { double dtelem_optimal = (*il).Pas_de_temps_ideal();
		    if (dtelem_optimal != 0.)
		      delta_optimal = MiN(delta_optimal, dtelem_optimal);		
		  };
  // retour du temps proposé
  if (delta_optimal==ConstMath::tresgrand)
    // cela veut dire qu'il n'a pas été modifié, on le met à 0 pour indiquer que l'on a rien
	 // n'a proposer
	 delta_optimal = 0.; 
  return delta_optimal;
};

//   écriture base info   
// cas donne le niveau de sauvegarde
void LesContacts::Ecri_base_info_LesContacts(ofstream& sort)
  { // globalement on sauvegarde toujours tout, car les éléments de contact peuvent apparaître à tout moment
    // tout d'abord on indique le type
    sort << "\n LesContacts: taille " << listContact.size() << "  " ;
		  // NB: le nombre de maillages esclave et en auto-contact, peut-être redéfinit lors d'un restart
		  // donc n'est pas sauvegardé
    // ensuite on sauvegarde la liste des éléments de contact: en fait tout d'abord les infos
	   // qui permettent de construire un élément ad hoc, et ensuite les infos spécifiques internes à l'élément
    for (LaLIST <ElContact>::iterator ic = listContact.begin();ic != listContact.end(); ic++)
      {// les infos permettants de contruire l'élément de contact: on considère que les numéros des noeuds, maillages, éléments
       // restent identiques, par contre on peut avoir d'un échange des zones de restriction de contact d'une sauvegarde à un restart 
       sort << "\nN_es " << (*ic).Esclave()->Num_Mail() <<" " << (*ic).Esclave()->Num_noeud();  // le noeud esclave
       Front * elfront = (*ic).Elfront();
       sort << " El " << elfront->NumMail() << " " << elfront->PtEI()->Num_elt_const() << " "
            <<  elfront->Eleme()->Type_geom_front()  << " "<< elfront->Num_frontiere() ; // la frontière
       // les infos spécifiques éventuelles
           (*ic).Ecri_base_info_ElContact(sort);
      };
    sort << "\n tps_rech_contact: "<<tempsContact;
  };


  // Il s'agit ici de mettre à jour les conteneurs stockés aux noeuds et/ou aux éléments
  // qui servent à récupérer les infos liés aux contact correspondant à liTQ
  // actuellement les conteneurs passés en paramètre ne servent que pour
  // les énumérés, et les informations résultantes sont stockées au niveau des noeuds
  // constituant les éléments de contact
  // absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
  //--> important : les conteneurs sont supposés initialisés avec l'appel
void LesContacts::Mise_a_jour_Pour_Grandeur_particuliere(
                                List_io < TypeQuelconque >& li_restreinte_TQ
                               )
{
   LaLIST<ElContact>::iterator ili_deb= listContact.begin();
   LaLIST<ElContact>::iterator ilifin= listContact.end();
   LaLIST<ElContact>::iterator ili;

   // on passe en revue la liste de quelconque
  {List_io<TypeQuelconque>::iterator itq,itqfin=li_restreinte_TQ.end();
   for (itq=li_restreinte_TQ.begin();itq!=itqfin;itq++)
     {const TypeQuelconque_enum_etendu& enuTypeQuelconque = (*itq).EnuTypeQuelconque();
      if (enuTypeQuelconque.Nom_vide()) // veut dire que c'est un enum pur
       switch (enuTypeQuelconque.EnumTQ())
       {  case NOEUD_PROJECTILE_EN_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              // on attribue une grandeur arbitraire de 100 aux noeuds pour un  contact actif
              // pour les éléments de contact inactif -> -0.1
              // un noeud peut être plusieurs fois en contact -> les nombres sont cumulées
              // on fait l'hypothèse qu'un ne sera jamais inactif plus de 99 fois, du coup
              // en regardant le nombre modulo 100 on peut en déduire le nombre d'inactivité
              // et en regardant le nombre de centaine on en déduit le nombre de contact
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += 100.; }
              else
               {*(tyTQ.ConteneurDouble()) -= 0.1; }
             };
            break;
           }
          case NOEUD_FACETTE_EN_CONTACT:
           {//  ----- cas des noeuds facettes en contact
            // on parcours la liste des éléments de contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              // on attribue une grandeur arbitraire de 100 aux noeuds pour un  contact actif
              // pour les éléments de contact inactif -> -0.1
              // un noeud peut être plusieurs fois en contact -> les nombres sont cumulées
              // on fait l'hypothèse qu'un ne sera jamais inactif plus de 99 fois, du coup
              // en regardant le nombre modulo 100 on peut en déduire le nombre d'inactivité
              // et en regardant le nombre de centaine on en déduit le nombre de contact
              Tableau <Noeud*>& tablN = elcont.TabNoeud();
              int NBNF=tablN.Taille();
              // on boucle sur les noeuds de la facette (le premier noeud = noeud esclave)
              if (elcont.Actif())
               {for (int i=2;i<=NBNF;i++)
                 {TypeQuelconque& tyqN = tablN(i)->ModifGrandeur_quelconque(enuTypeQuelconque);
                  Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
                  *(tyTQ.ConteneurDouble()) += 100.;
                 }
               }
              else
               {for (int i=2;i<=NBNF;i++)
                 {TypeQuelconque& tyqN = tablN(i)->ModifGrandeur_quelconque(enuTypeQuelconque);
                  Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
                  *(tyTQ.ConteneurDouble()) -= 0.1;
                 }
               };
             };
            break;
           }
          case PENETRATION_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            // on parcours la liste des élément en contact
            //  on cumule s'il y a plusieurs contacts
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {// on définit un vecteur au niveau du noeud en contact, qui part du noeud
                // projectile et va au point d'impact
                const Coordonnee& Mtdt = elcont.Point_intersection();
                *(tyTQ.ConteneurCoordonnee()) += Mtdt - elcont.Esclave()->Coord2();
               }; // sinon on ne fait rien
             };
            break;
           }
          case GLISSEMENT_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            // on parcours la liste des élément en contact
            //  on cumule s'il y a plusieurs contacts
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {// on définit un vecteur au niveau du noeud en contact, qui part du noeud
                // projectile et va au point d'impact
                *(tyTQ.ConteneurCoordonnee()) += elcont.Dep_tangentiel();
               }; // sinon on ne fait rien
             };
            break;
           }
          case NORMALE_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            // on parcours la liste des élément en contact
            //  on cumule s'il y a plusieurs contacts
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {// on définit un vecteur au niveau du noeud en contact, qui part du noeud
                // projectile et va au point d'impact
                *(tyTQ.ConteneurCoordonnee()) += elcont.Normale_actuelle();
               }; // sinon on ne fait rien
             };
            break;
           }
          case FORCE_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_coordonnee& tyTQ= *((Grandeur_coordonnee*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {// on récupère la force de contact
                *(tyTQ.ConteneurCoordonnee()) += elcont.Force_contact();
               }; // sinon on ne fait rien
             };
            break;
           }
          case CONTACT_PENALISATION_N:
           {//  ----- on attribue la pénalisation au noeud projectile
            //  on met la pénalisation totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Penalisation(); };
             };
            break;
           }
          case CONTACT_PENALISATION_T:
           {//  ----- on attribue la pénalisation au noeud projectile
            //  on met la pénalisation totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Penalisation_tangentielle(); };
             };
            break;
           }
          case CONTACT_ENERG_PENAL:
           {//  ----- on attribue l'énergie de pénalisation au noeud projectile
            //  on met l'énergie totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.EnergiePenalisation(); };
             };
            break;
           }
          case CONTACT_ENERG_GLISSE_ELAS:
           {//  ----- on attribue l'énergie de pénalisation au noeud projectile
            //  on met l'énergie totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().EnergieElastique(); };
             };
            break;
           }
          case CONTACT_ENERG_GLISSE_PLAS:
           {//  ----- on attribue l'énergie de pénalisation au noeud projectile
            //  on met l'énergie totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().DissipationPlastique(); };
             };
            break;
           }
          case CONTACT_ENERG_GLISSE_VISQ:
           {//  ----- on attribue l'énergie de pénalisation au noeud projectile
            //  on met l'énergie totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.EnergieFrottement().DissipationVisqueuse(); };
             };
            break;
           }
          case CONTACT_NB_DECOL:
           {//  ----- on attribue le nombre de décolement au noeud projectile
            //  on met le totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Nb_decol(); };
             };
            break;
           }
          case CONTACT_COLLANT:
           {//  ----- on attribue le fait d'être collant ou pas au noeud projectile
            //  on met le totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Collant(); };
             };
            break;
           }
          case NUM_ZONE_CONTACT:
           {//  ----- on attribue le numéro de zone de contact au noeud projectile
            //  on met le totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Num_zone_contact(); };
             };
            break;
           }
          case CONTACT_NB_PENET:
           {//  ----- on attribue le nombre de décolement au noeud projectile
            //  on met le totale s'il y a plusieurs contacts
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) += elcont.Nb_pene(); };
             };
            break;
           }
          case CONTACT_CAS_SOLIDE:
           {//  ----- on attribue le nombre au noeud projectile
            // =0 contact bi déformable, =1 le noeud est libre et la frontière est bloqué (solide)
            // = 2 le noeud est bloqué (solide) la frontière est libre
            // = 3 tout est solide

            //  ici on ne met pas le totale s'il y a plusieurs contacts !!
            // c'est le dernier élément qui contient le noeud projectile, qui donne le résultat
            
            // on parcours la liste des élément en contact
            for (ili=ili_deb;ili!=ilifin;ili++)
             {ElContact & elcont = (*ili); // pour simplifier
              TypeQuelconque& tyqN = elcont.Esclave()->ModifGrandeur_quelconque(enuTypeQuelconque);
              Grandeur_scalaire_double& tyTQ= *((Grandeur_scalaire_double*)
                                                     tyqN.Grandeur_pointee());
              if (elcont.Actif())
               {*(tyTQ.ConteneurDouble()) = elcont.Cas_solide(); };
             };
            break;
           }

          default: ;// on ne fait rien
       };

	    };
   };
 

};
   
// récupération de la liste de tous les grandeurs particulières disponibles avec le contact
// cette liste est identique quelque soit le maillage: il n'y a donc pas de tableau indicé du num de maillage
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
List_io<TypeQuelconque> LesContacts::ListeGrandeurs_particulieres(bool absolue) const
 {
  // def de la liste de retour
  List_io <TypeQuelconque> liTQ;
  
  // on ne ramène les infos que si le contact est actif
  if (ParaGlob::param->ParaAlgoControleActifs().ContactType()!= 0)
    {
      // grandeurs de travail
      int dim = ParaGlob::Dimension();
     
      // ici on est en 3D et les grandeurs sont par principe en absolue, donc la variable absolue ne sert pas
      Grandeur_scalaire_double grand_courant(0.);
      
      Coordonnee  inter(dim);
      Grandeur_coordonnee   grand_coor_courant(inter);
      
      // def d'un type quelconque représentatif à chaque grandeur
      // a priori ces grandeurs sont défini aux noeuds
      //on regarde si ce type d'info existe déjà: si oui on augmente la taille du tableau, si non on crée
      // $$$  cas de la visualisation des noeuds projectiles en contact
      {TypeQuelconque typQ1(NOEUD_PROJECTILE_EN_CONTACT,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      // $$$  cas de la visualisation des noeuds des facettes en contact
      {TypeQuelconque typQ1(NOEUD_FACETTE_EN_CONTACT,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      // $$$  cas de la visualisation du glissement des noeuds projectiles actifs
      {TypeQuelconque typQ1(GLISSEMENT_CONTACT,X1,grand_coor_courant);
       liTQ.push_back(typQ1);
      };
      // $$$  cas de la visualisation du glissement des noeuds projectiles actifs
      {TypeQuelconque typQ1(NORMALE_CONTACT,X1,grand_coor_courant);
       liTQ.push_back(typQ1);
      };
      // $$$  cas de la visualisation de la pénétration en contact
      {TypeQuelconque typQ1(PENETRATION_CONTACT,X1,grand_coor_courant);
       liTQ.push_back(typQ1);
      };
      // $$$  cas de la visualisation des forces de contact
      {TypeQuelconque typQ1(FORCE_CONTACT,X1,grand_coor_courant);
       liTQ.push_back(typQ1);
      };
      //  $$$ nombre de pénétration
      {TypeQuelconque typQ1(CONTACT_NB_PENET,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      //  $$$ nombre de décolement
      {TypeQuelconque typQ1(CONTACT_NB_DECOL,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      //  $$$ cas_solide
      {TypeQuelconque typQ1(CONTACT_CAS_SOLIDE,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_ENERG_PENAL,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_ELAS,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_PLAS,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_ENERG_GLISSE_VISQ,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_PENALISATION_N,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_PENALISATION_T,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
      {TypeQuelconque typQ1(CONTACT_COLLANT,X1,grand_courant);
       liTQ.push_back(typQ1);
      };
     {TypeQuelconque typQ1(NUM_ZONE_CONTACT,X1,grand_courant);
      liTQ.push_back(typQ1);
     };
    };
  
  // retour
  return liTQ;

 };


  // concernant les grandeurs gérées par le contact:
  // ramène une liste d'enuméré correspondant aux List_io<TypeQuelconque> passé en paramètre
  // idem pour une List_io < Ddl _enum_etendu >
void LesContacts::List_reduite_aux_contact(const List_io<TypeQuelconque>& liTQ
                                            ,List_io < TypeQuelconque >& li_restreinte_TQ
                                           )
  {
   // initialisation des listes de retour
   li_restreinte_TQ.clear();
   // on passe en revue la liste
   List_io<TypeQuelconque>::const_iterator itq,itqfin=liTQ.end();
   for (itq=liTQ.begin();itq!=itqfin;itq++)
     {const TypeQuelconque& tipParticu = (*itq); // pour simplifier
      const TypeQuelconque_enum_etendu& enuTypeQuelconque = tipParticu.EnuTypeQuelconque();
      if (enuTypeQuelconque.Nom_vide()) // veut dire que c'est un enum pur
       switch (enuTypeQuelconque.EnumTQ())
       {  case NOEUD_PROJECTILE_EN_CONTACT:  case NOEUD_FACETTE_EN_CONTACT:
          case PENETRATION_CONTACT:          case FORCE_CONTACT:
          case CONTACT_PENALISATION_N:       case CONTACT_PENALISATION_T:
          case CONTACT_ENERG_PENAL:          case NORMALE_CONTACT:
          case GLISSEMENT_CONTACT:           case CONTACT_ENERG_GLISSE_ELAS:
          case CONTACT_ENERG_GLISSE_VISQ:    case CONTACT_ENERG_GLISSE_PLAS:
          case CONTACT_NB_DECOL:             case CONTACT_NB_PENET:
          case CONTACT_CAS_SOLIDE:           case CONTACT_COLLANT:
          case NUM_ZONE_CONTACT:
           {//  ----- cas des noeuds projectiles en contact
            li_restreinte_TQ.push_front(TypeQuelconque(tipParticu));
            break;
           }
          default: ;// on ne fait rien
       };
     };
  };

// initialisation des listes de grandeurs qu'ils faudra transférérer aux niveaux des noeuds des élements
// de contact, on définit si besoin, les conteneurs ad hoc au niveau des noeuds
void LesContacts::Init_Grandeur_particuliere (bool absolue,List_io<TypeQuelconque>& liTQ)
  {liQ_en_sortie = liTQ; // on récupère la liste --> sans doute que cela ne sert à rien

   LaLIST<ElContact>::iterator ili_deb= listContact.begin();
   LaLIST<ElContact>::iterator ilifin= listContact.end();
   LaLIST<ElContact>::iterator ili;

   // on passe en revue la liste
   List_io<TypeQuelconque>::iterator itq,itqfin=liTQ.end();
   //    on part du principe qu'il y a plus de noeuds en contact que de grandeur donc on fait une
   //    boucle externe sur les noeuds en contact:  on parcours la liste des noeuds en contact
   for (ili=ili_deb;ili!=ilifin;ili++)
    {ElContact& elcont = (*ili); // pour simplifier
     for (itq=liTQ.begin();itq!=itqfin;itq++)
      {TypeQuelconque& tipParticu = (*itq); // pour simplifier
       EnumTypeQuelconque enuTQ = tipParticu.EnuTypeQuelconque().EnumTQ();

       switch (enuTQ)
          { case NOEUD_PROJECTILE_EN_CONTACT:  case NOEUD_FACETTE_EN_CONTACT:
            case GLISSEMENT_CONTACT:           case PENETRATION_CONTACT:
            case FORCE_CONTACT:                case CONTACT_NB_PENET:
            case CONTACT_PENALISATION_N:       case CONTACT_PENALISATION_T:
            case CONTACT_NB_DECOL:             case CONTACT_CAS_SOLIDE:
            case CONTACT_ENERG_PENAL:          case CONTACT_COLLANT:
            case NUM_ZONE_CONTACT:
            case NORMALE_CONTACT:              case CONTACT_ENERG_GLISSE_ELAS:
            case CONTACT_ENERG_GLISSE_VISQ:    case CONTACT_ENERG_GLISSE_PLAS:
            
             {//  ----- cas des noeuds projectiles en contact
              elcont.Esclave()->AjoutUnTypeQuelconque(*itq); // ajout du conteneur
              break;
             }
            default: ; // sinon rien
          };
       };
    };

  } ;

//==========================  fonction protegee =============================

// mise à jour des boites d'encombrement pour les éléments qui contiennent une frontière
void LesContacts::Mise_a_jour_boite_encombrement_element_contenant_front()
 {
   list  <Element *>::iterator il,ilfin = liste_elemens_front.end();
   for (il = liste_elemens_front.begin();il!=ilfin;il++)
      (*il)->Boite_encombre_element(TEMPS_tdt);

 };

// suppression du gap de contact pour les noeuds "collant avec suppression de gap"
void LesContacts::Suppression_gap_pour_noeud_collant()
  {
    int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
    if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
    // on passe en revue les zones de contact et si nécessaire on supprime les gaps
    // sinon retour
    bool continuer = false; // init par défaut
    //     list <quatre_string_un_entier> nom_ref_zone_contact; // liste des noms de références des zones de contact
    list <quatre_string_un_entier>::iterator iu,iufin = nom_ref_zone_contact.end();
    for (iu = nom_ref_zone_contact.begin();iu != iufin; iu++)
     if ((*iu).n == 2)
       {continuer = true; break;};
    if (!continuer)
      return;
   
    // sinon il faut effectivement faire une suppression de gap
    if (niveau_commentaire_contact > 2)
     cout << "\n >>>> Suppression_gap_pour_noeud_collant : ";
    // on va iterer sur les noeuds esclaves collants dont on veut supprimer le gap
    LaLIST_io <Front>::iterator iM,iMfin; // des itérator de travail
    int nb_zone = MaX(1,nom_ref_zone_contact.size());
    double dist_max =  Dabs(ParaGlob::param->ParaAlgoControleActifs().DistanceMaxiAuPtProjete());
   
    int tout_projeter = true; // init
    int boucle_maxi = 10; // 10 boucle maxi
    int boucle = 1;
    do
     { if (niveau_commentaire_contact >2 )
           cout << "\n boucle : "<<boucle << flush;
       for (int intot = 1;intot<= nb_mail_Esclave;intot++) // boucle sur les maillages esclaves
        for (int j=1;j<=nb_zone;j++) // boucle sur les zones de contact
         {const Tableau <Noeud*>& tesc= tesctotal(intot)(j); // pour simplifier la notation:
          const Tableau <int> tesN_col = tesN_collant(intot)(j); // pour simplifier
          int tesc_taille=tesc.Taille();                   //  tab des noeuds esclaves à considérer
          int compteur_noeuds_projecte=0; // le nombre de noeuds qui sont projetés
          double le_maxi_des_distances_trouve = 0.;
          for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
           if (tesN_col(inesc) == 2 ) // cas noeud collant avec volonté de supprimer le gap
            { Noeud* noee = tesc(inesc); // pour simplifier
    //--- debug
   //if (noee->Num_noeud() == 5)
   // {cout << "\n arrivée au bon element ";
   // }
              const Coordonnee pt_esc = noee->Coord0(); // position du noeud esclave initial
              list <Coordonnee > list_P; // la liste des projetés
              list <LaLIST_io <Front>::iterator> li_pt_front_P; // liste sur les faces pour le debug
              for (int jlf=1;jlf<=nbmailMaitre;jlf++) // boucle sur les maillages maitres
               {//Tableau < Tableau < LaLIST_io <Front> > >  t_listFront;
                LaLIST_io <Front>& t_l_front = t_listFront(jlf)(j);
                iMfin=t_l_front.end();
                for (iM = t_l_front.begin() ; iM != iMfin; iM++) // boucle sur les front maitres
                 {// si c'est dans le volume de la frontière augmenté de la distance ad hoc on test
                  // plus précisément
                  if ((*iM).In_boite_emcombrement_front(pt_esc,dist_max))
                   {// on projete le noeud sur la frontière
                    Coordonnee P;
   ////--- debug
   //if ((noee->Num_noeud() == 5) && ((*iM).PtEI()->Num_elt()==367))
   // {cout << "\n arrivée au bon element ";
   //
   // }
   //{double Ndis = (P-pt_esc).Norme();
   // if (Ndis > 20)
   //   (*iM).Eleme()->Projection_normale(pt_esc,P);
   //}
   //-- fin debug

   // //----debug
   //{if ((noee->Num_noeud() == 12)
   //     && ((*iM).Num_frontiere() == 1) && ((*iM).PtEI()->Num_elt() == 3130))
   //    { cout << "\n debug : frontiere 1 de l'element 3130";}
   //}
   ////----fin debug

                    // si la projection est valide on enregistre
                    if ((*iM).Eleme()->Projection_normale(pt_esc,P))
                      { list_P.push_back(P);
                        li_pt_front_P.push_back(iM);
                      };
   //--- debug
   //{double Ndis = (P-pt_esc).Norme();
   // if (Ndis > 20)
   //   (*iM).Eleme()->Projection_normale(pt_esc,P);
   //}
   //-- fin debug
                  
                   };
                 };
               };
              // maintenant on va garder le plus proche
              bool projection_ok = false; // init
              if (list_P.size() != 0)
               {list <Coordonnee >::iterator il,ilfin=list_P.end();
                if (niveau_commentaire_contact >5 )
                  {cout << "\n " << list_P.size() << " proj trouvees   "
                        << " Noe: "<<noee->Num_noeud()
                        << " mail: " <<  noee->Num_Mail() << " (zone"<<j<<")";
                  };
                Coordonnee M = pt_esc;  // init
                Coordonnee P(M); // la projection
                double distance =  dist_max;
                LaLIST_io <LaLIST_io <Front>::iterator>::iterator iface = li_pt_front_P.begin();
                LaLIST_io <LaLIST_io <Front>::iterator>::iterator iface_maxi ;
                for (il=list_P.begin(); il!= ilfin;il++,iface++)
                 { double Ndis = (M-(*il)).Norme();
                   if (niveau_commentaire_contact >5 )
                     cout << " dist: "  << Ndis ;
                   if (Ndis < distance)
                    {P = (*il); distance = Ndis;
                     projection_ok = true; // au moins un nouveau point
                     iface_maxi = iface;
                    };
                 };
                // si la distance == 0., il n'y a pas à changer les coordonnées
                // car le point projeté == le point initial 
                if (distance > ConstMath::petit)
                 {// on change les coordonnées du noeud
                  noee->Change_coord0(P);
                  noee->Change_coord1(P);
                  noee->Change_coord2(P);
                  compteur_noeuds_projecte++;
                  tout_projeter=false;
                  if (distance > le_maxi_des_distances_trouve)
                    le_maxi_des_distances_trouve = distance;
                  if (niveau_commentaire_contact >3 )
                     cout << "\n suppression gap=("<<distance<<") du noeud "<<noee->Num_noeud()
                          << " du maillage " <<  noee->Num_Mail() << " (zone "<<j<<")";
                  if (niveau_commentaire_contact >4 )
                    {cout << "\n ancienne coordonnee "<< pt_esc
                          << " nouvelle " << P;
                     // dans le cas où iface_maxi a été attribué
                     if (projection_ok)
                       (*(*iface_maxi)).Affiche();
               
   ////--- debug
   //{
   //const Coordonnee pt_esc  = noee->Coord0();
   //Coordonnee PP;
   //(*(*iface_maxi)).Eleme()->Projection_normale(pt_esc,PP);
   //cout << "\n $$$ nouvelle coordonnees projetee "<< PP;
   //}
   ////-- fin debug

                    };
                 }
                else if (projection_ok)
                  // si on n'a pas de projection avec changement de position
                  // mais par contre on a quand même trouvé un projeté on enregistre
                 {compteur_noeuds_projecte++;};
               };
              if ((!projection_ok) && (boucle==1)) // au premier passage
               { if (niveau_commentaire_contact >3 )
                   cout << "\n pas de projection trouvee donc de suppression gap du noeud "<<noee->Num_noeud()
                        << " du maillage" <<  noee->Num_Mail() << " (zone "<<j<<")";
               } ;
            }; //-- fin de la boucle sur inesc
          if (niveau_commentaire_contact >2 )
           {if (compteur_noeuds_projecte)
                 cout << "\n zone: " << j <<", " << compteur_noeuds_projecte << " suppression(s) de gap, maxi_distance= "
                      << le_maxi_des_distances_trouve << "( passage"<<boucle<<")" ;
            int non_gap = tesc_taille-compteur_noeuds_projecte;
            if ((non_gap)&& (boucle==1)) // au premier passage
              cout << "\n  zone: " << j <<", *** attention pour "<<non_gap
                   << " noeud(s) pas de projection trouvee !! ";
           };
        }; //-- fin de la boucle sur intot
       boucle++;
     }
    while ((!tout_projeter) && (boucle < boucle_maxi));
//     Sortie(1);
  };

// récupération de la zone de contact d'un élément de contact existant
// c'est un peu lourdinge, mais l'avantage c'est que cela s'adapte à une situation qui
// a par exemple changé
// si en retour le numéro de zone = 0, cela signifie que le contact ne peut plus exister
int LesContacts::Recup_ref( ElContact& al)
 { int nb_zone = MaX(1,nom_ref_zone_contact.size());
   const Tableau <Noeud*>& tn = al.TabNoeud();
   int num_mail_esclave = tn(1)->Num_Mail();
   int num_mail_maitre = tn(2)->Num_Mail();
   int num_noe = tn(1)->Num_noeud();
  
   // on parcours la liste des frontières succeptibles d'entrer en contact
   // pour repérer la zone
   int num_zone = 0; // init
   int nb_maitre = t_listFront.Taille();
   int nb_esclave = tesctotal.Taille();
   for (int i=1;i<=nb_maitre;i++)
    {for (int j=1;j<=nb_zone;j++)
      {LaLIST_io <Front> & list_fronta = t_listFront(i)(j); // pour simplifier
       LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
       for (il = list_fronta.begin();il != ilfin; il++)
         {if ((*il)==(*al.Elfront()))
           // les deux pointeurs pointent sur la même frontière, donc
           // maintenant on regarde du coté des noeuds esclaves
           { for (int ie = 1; ie<=nb_esclave;ie++)
              {const Tableau <Noeud*>& tesc= tesctotal(i)(j); // pour simplifier la notation:
               int tesc_taille=tesc.Taille();                   //  tab des noeuds esclaves à considérer
               for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
                {if (tesc(inesc) == al.Esclave())
                  // les deux pointeurs pointent sur le même noeud, c'est ok
                  {num_zone = j; break;};
                };
               if (num_zone)
                 break;
              };
           };
          if (num_zone)
             break;
         };
       if (num_zone)
          break;
      };
     if (num_zone)
        break;
    };
   // retour des infos
   return num_zone;
 };


  // création d'un tableau de condition linéaire, correspondant à tous les éléments de contact en cours
  // qu'ils soient actifs ou pas (a prior cette méthode est conçu pour donner des infos relativement à la largeur
  // de bandes en noeuds due aux CLL)
  // chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL,
const Tableau <Condilineaire>&   LesContacts::ConnectionCLL()
   {
     // on boucle sur le tableau et pour chaque element on crée une condition lineaire
     int tabTaille = listContact.size();
     t_connectionCLL.Change_taille(tabTaille);
     // un tableau servant à la def de la CLL
     Tableau <Enum_ddl > t_enu(1); t_enu(1)=X1 ;
     LaLIST <ElContact>::const_iterator il,ilfin=listContact.end();
     int posi=1; // init pour le tableau
     for (il=listContact.begin();il != ilfin;il++,posi++)
      { const Tableau < Noeud *>& t_n = (*il).Const_TabNoeud();
        // on est dans le cas ou l'on connait les infos relatives uniquements aux noeuds, aux enum ddl
        t_connectionCLL(posi) = Condilineaire(t_enu, t_n);
      };

     // retour
     return t_connectionCLL;
   };


// récupère le nombre de contact actif et met à jour ce nombre
// normalement devrait toujours être correct mais ?? il y a quelque chose d'incorrecte quelque part
int LesContacts::Recalcul_Nb_contact_actif()
  {  LaLIST <ElContact>::iterator il,ilfin = listContact.end();
     int ancien_nb_contact_actif = nb_contact_actif;
     nb_contact_actif = 0; // init
     for (il = listContact.begin();il != ilfin; il++)
       if ((*il).Actif())
          nb_contact_actif++;
   
     int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
     if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
     if (nb_contact_actif != ancien_nb_contact_actif)
       if (niveau_commentaire_contact > 4)
         cout << "\n mise a jour anormale du nombre de contact actif : "
              << " ancien_nb_contact_actif= " << ancien_nb_contact_actif
              << " nouveau_nombre= " << nb_contact_actif << endl;
     return nb_contact_actif;
  };


// création du conteneur Fct_nD_contact
void LesContacts::Creation_Fct_nD_contact()
 {

  {// cas de la penalisation normale
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penalisationPenetration();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_penalisationPenetration = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la penalisation normale "
              << " le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_penalisationPenetration=NULL;};
  };

  {// cas fct_nD_penetration_contact_maxi
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penetration_contact_maxi();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_penetration_contact_maxi = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la  "
              << " penetration maxi, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_penetration_contact_maxi=NULL;};
  };
  
  {// cas Fct_nD_penetration_borne_regularisation
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penetration_borne_regularisation();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_penetration_borne_regularisation = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
              << " borne de regularisation, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_penetration_borne_regularisation=NULL;};
  };
  
  {// cas fct_nD_force_contact_noeud_maxi
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_force_contact_noeud_maxi();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_force_contact_noeud_maxi = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la "
              << " force de contact normale, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_force_contact_noeud_maxi=NULL;};
  };
  
  {// cas fct_nD_penalisationTangentielle
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_penalisationTangentielle();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_penalisationTangentielle = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la penalisation tangentielle "
              << " le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_penalisationTangentielle=NULL;};
  };
  
  {// cas fct_nD_tangentielle_contact_maxi
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_tangentielle_contact_maxi();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_tangentielle_contact_maxi = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage du "
              << " deplacement tangentiel maxi, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_tangentielle_contact_maxi=NULL;};
  };
  
  {// cas fct_nD_tangentielle_borne_regularisation
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_tangentielle_borne_regularisation();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_tangentielle_borne_regularisation = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la  "
              << " borne de regularisation tangentielle, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_tangentielle_borne_regularisation=NULL;};
  };
  
  {// cas fct_nD_force_tangentielle_noeud_maxi
   string nom_fct = ParaGlob::param->ParaAlgoControleActifs().Fct_nD_force_tangentielle_noeud_maxi();
   if (nom_fct != "_")
     {// on va récupérer la fonction
      if (sauve_lesFonctionsnD->Existe(nom_fct))
       { Fonction_nD * pt_fonct = sauve_lesFonctionsnD->Trouve(nom_fct);
         // sauvegarde
         fct_nD_contact.fct_nD_force_tangentielle_noeud_maxi = pt_fonct;
       }
      else
       { cout << "\n *** erreur dans la definition de la fonction nD de pilotage de la  "
              << " force tangentielle maxi, le nom : " << nom_fct
              << " ne correspond pas a une fonction nD existante !! ";
         Sortie(1);
       };
     }
   else
     {fct_nD_contact.fct_nD_force_tangentielle_noeud_maxi=NULL;};
  };
 
 };

/*// mise à jour du stockage inter, pour prendre en
// compte une nouvelle numérotation des noeuds
void LesContacts::Prise_en_compte_nouvelle_numerotation_noeud()
 { //on va reconstruire ta_inverse
   int nb_zone = MaX(1,nom_ref_zone_contact.size());
   // on garde en mémoire les anciens numéros pour faire le pontage
   Tableau < Tableau < Tableau <int> > >  ta_inverse_old(ta_inverse);
  
   // on recherche les maxi des numéros de noeuds esclave, pour dimensionner ta_inverse !!
   Tableau < Tableau <int> > maxi_num_noe_esclave(nb_mail_Esclave); // init à 0
   for (int i=1;i<=nb_mail_Esclave;i++)
    {maxi_num_noe_esclave(i).Change_taille(nb_zone);
     for (int j=1;j<=nb_zone;j++)
      {const Tableau <Noeud*>& tesc= tesctotal(i)(j); // pour simplifier la notation:
       int tesc_taille=tesc.Taille();                   //  tab des noeuds esclaves à considérer
       int& max_num_esclave = maxi_num_noe_esclave(i)(j); // pour simplifier
       for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
           { Noeud* noee = tesc(inesc); // pour simplifier
             int num_noeud = noee->Num_noeud();
             if (num_noeud > max_num_esclave)
                 max_num_esclave = num_noeud;
           };
      };
    };
   // Maintenant on peut dimensionner ta_inverse
   for (int i=1;i<=nb_mail_Esclave;i++)
    {ta_inverse(i).Change_taille(nb_zone);
     for (int j=1;j<=nb_zone;j++)
      ta_inverse(i)(j).Change_taille(maxi_num_noe_esclave(i)(j),0);
    };

   // ensuite on va remplir  ta_inverse
   for (int intot=1;intot<=nb_mail_Esclave;intot++)
    {for (int j=1;j<=nb_zone;j++)
       {const Tableau <Noeud*>& tesc= tesctotal(intot)(j); // pour simplifier la notation:
        int tesc_taille=tesc.Taille();                   //  tab des noeuds esclaves à considérer
        for (int inesc = 1;inesc<= tesc_taille;inesc++) // boucle sur les noeuds esclaves
           { Noeud* noee = tesc(inesc); // pour simplifier
             ta_inverse(intot)(j)(noee->Num_noeud()) = inesc;
           };
       };
    };
  
   // on va créer un tableau de changement des numéros de noeuds
   Tableau < Tableau <int> > nouveau_Noe(nb_mail_Esclave);
   // on cherche la taille maxi
   Tableau <int>  maxi_maxi_num_noe_esclave(nb_mail_Esclave); // les maxis pour chaque maillage
   for (int i=1;i<=nb_mail_Esclave;i++)
    {int& max_max_esclave = maxi_maxi_num_noe_esclave(i) = 0; // init
     for (int j=1;j<=nb_zone;j++)
      {int& max_num_esclave = maxi_num_noe_esclave(i)(j); // pour simplifier
       if (max_num_esclave > max_max_esclave)
         max_max_esclave = max_num_esclave;
      };
    };
   // on balaie les anciens noeuds
   for (int i=1;i<=nb_mail_Esclave;i++)
    {nouveau_Noe(i).Change_taille(maxi_maxi_num_noe_esclave(i));
     Tableau <int>& nouveau_Noe_i = nouveau_Noe(i);
     for (int j=1;j<=nb_zone;j++)
      { Tableau <int> & ta_inverse_old_ij = ta_inverse_old(i)(j);
        Tableau <int> & ta_inverse_ij = ta_inverse(i)(j);
        int nbN = ta_inverse_old_ij.Taille();
        for (int k=1;k<= nbN;k++) // k c'est le numéro de l'ancien noeud
         {if (ta_inverse_old_ij(k) != 0)
           {for (int k2=1;k2<= nbN;k2++)
             { if (ta_inverse_old_ij(k) == ta_inverse_ij(k2))
                 {nouveau_Noe_i(k)=k2;break;};
             };
           };
         };
      };
    };
  
//  // maintenant on met à jour le tableau tesN_encontact
//  //     Tableau < Tableau < LaLIST < LaLIST<ElContact>::iterator > > >  tesN_encontact;
//  // on sauvegarde l'ancien
//  Tableau < Tableau < LaLIST < LaLIST<ElContact>::iterator > > >  tesN_encontact_old(tesN_encontact);
//  // et on fait la passation
//  for (int i=1;i<=nb_mail_Esclave;i++)
//   {Tableau <int>& nouveau_Noe_i = nouveau_Noe(i);
//    int nbn = tesN_encontact(i).Taille();
//    for (int j=1;j<=nbn;j++)
//     { tesN_encontact(i)(nouveau_Noe_i(j)) = tesN_encontact_old(i)(j);
//     };
//   };
  
  // on continue avec le tableau: liste pour chaque noeud, des éléments qui contient ce noeud
  // indice(i)(j) : = la liste des éléments qui contiennent le noeud j, pour le maillage i
  Tableau < const Tableau <List_io < Element* > > *>  indice_old(indice);
  int nb_mail = indice_old.Taille();
  for (int i=1;i<=nb_mail;i++)
   {if (indice_old(i) != NULL)
     { int nbn = indice_old(i)->Taille();
//       const Tableau <List_io < Element* > > & indice_i = indice(i);
//       for (int j=1;j<=nbn;j++)
//indice
     
     }
   
   }
cout << "\n LesContacts::Prise_en_compte_nouvelle_numerotation_noeud() pas terminé !!"
     << " il faut changer lesMaillages pour récupérer directement la nouvelle numérotation !!";
Sortie(1);

 };
*/


// récupération via les éléments de contact des forces maxis
// et affichage éventuel
// un : le maxi en effort normal, deux: le maxi en effort tangentiel
DeuxDoubles LesContacts::Forces_contact_maxi(bool affiche) const
 {DeuxDoubles retour;
  LaLIST <ElContact>::const_iterator il,ilfin = listContact.end();
  for (il = listContact.begin();il != ilfin; il++)
     { const ElContact& icont = (*il); // pour simplifier
       double fNmax =  icont.F_N_MAX();
       double fTmax =  icont.F_T_MAX();
       if (Dabs(fNmax) > Dabs(retour.un) )
         retour.un = fNmax;
       if (Dabs(fTmax) > Dabs(retour.deux) )
         retour.deux = fTmax;
     };
  int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
  if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
  if ((affiche && (ParaGlob::NiveauImpression() > 2))
      || (niveau_commentaire_contact > 5) // spécifiquement pour le contact
     )
      cout << "\n contact: reaction ==> F_N max " << retour.un << " F_T max " << retour.deux;
  return retour;
 };

// récupération via les éléments de contact des gaps maxis
// un : le maxi en gap normal, deux: le maxi en gap tangentiel
DeuxDoubles LesContacts::Gap_contact_maxi(bool affiche) const
 {DeuxDoubles retour;
  LaLIST <ElContact>::const_iterator il,ilfin = listContact.end();
  for (il = listContact.begin();il != ilfin; il++)
     { const ElContact& icont = (*il); // pour simplifier
       double fNmax =  icont.Gaptdt();
       double fTmax =  icont.Dep_T_tdt();
       if (Dabs(fNmax) > Dabs(retour.un) )
         retour.un = fNmax;
       if (Dabs(fTmax) > Dabs(retour.deux) )
         retour.deux = fTmax;
     };
  int niveau_commentaire_contact = ParaGlob::param->ParaAlgoControleActifs().Niveau_commentaire_contact();
  if (niveau_commentaire_contact == 0) {niveau_commentaire_contact = ParaGlob::NiveauImpression();};
  if ((affiche && (ParaGlob::NiveauImpression() > 2))
      || (niveau_commentaire_contact > 5) // spécifiquement pour le contact
     )
      cout << ", maxi gap_N : " << retour.un << " gap_T : " << retour.deux;
  return retour;
 };