// FICHIER : Met_Sfe1.cc
// CLASSE : Met_Sfe1


// 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 <iostream>
using namespace std;  //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "Util.h"
#include "MathUtil.h"


#include "Met_Sfe1.h"


//  =========================================================================================
//  vu la taille des executables le fichier est decompose en quatre
// le premier : Met_Sfe1s1.cp concerne les constructeurs, destructeur et 
//              la gestion des variables
// le second :  Met_Sfe1s2.cp concerne  le calcul des grandeurs publics
// le troisieme : Met_Sfe1s3.cp concerne  le calcul des grandeurs protegees, et des courbures pour SFE1 et SFE2 et QSFE1
// le quatrième : Met_Sfe1s4.cp concerne  le calcul des courbures pour les éléments SFE3 et QSFE3
//  =========================================================================================

// METHODES PUBLIQUES :
//  ------------------------ calculs ----------------------------------------
	 // cas explicite à t, toutes les grandeurs sont a 0 ou t	
	 // gradV_instantane : true : calcul du gradient de vitesse instantannée 
     // premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
     //                  false: uniquement les grandeurs à t sont calculées	    
  const Met_abstraite::Expli&  Met_Sfe1::CalSfe1_explicit_t
		         ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{// récu
	 if ((epas != NULL)&&(!tCalEpais)) epais = *epas;
	 if (premier_calcul)
	   {// Base a t=0 : 
	   // -----tout d'abord on calcul les elements relatifs a la surface médiane -----
         // partie a_alpha
	     Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
	     if (tCalEpais) // cas 3D
            {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_0();                         // la normale 
             Calcul_a_3_B_0();                     // le troisième vecteur 
             };  
	     *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
      // calcul du jacobien de la facette centrale sans courbure
      Met_abstraite::Jacobien_0();         // calcul du jacobien a 0
      ajacobien_0 = jacobien_0; // sauvegarde
      Met_abstraite::Calcul_gijBB_0 ();    // metrique base naturelle
  	   *aijBB_0 = *gijBB_0;
  	   Met_abstraite::Calcul_gijHH_0 ();        // composantes controvariantes
  	   *aijHH_0 = *gijHH_0;	
       Met_abstraite::Calcul_giH_0(); 
  	   *aiH_0 = *giH_0; // sauvegarde
	   // ----- puis la courbure à t=0 -----
  	   // calcul de la coubure a 0
  	   curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
      Cal_N_alpha_0(); // N,alpha
	   // ----- puis la base dans l'épaisseur à t=0 -----
  	   //la base a t0
  	   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
	     Met_abstraite::Calcul_gijBB_0 ();  // metrique base naturelle
	     Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
      Met_abstraite::Calcul_giH_0();
	     if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	          Met_abstraite::Jacobien_0();         // calcul du jacobien a 0
	   };
	 // ici on ne met pas la partie à t dans le cas d'un premier calcul car il n'y a pas de grandeur
	 // à t+dt, d'où les grandeurs à t vont jouer le rôle de grandeur à tdt 
     // Base a t=t : 
	 // ------  1) tout d'abord la partie médiane à t	 ------  
	 Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t
	 if (tCalEpais) // cas 3D
     {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées
      Calcul_N_t();                         // la normale 
      Calcul_a_3_B_t();                     // le troisième vecteur 
     };
	 *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
  // calcul du jacobien de la facette centrale sans courbure
  Met_abstraite::Jacobien_t();         // calcul du jacobien a t
  ajacobien_t = jacobien_t; // sauvegarde
	 Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t; // metrique base naturelle
	 Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t; // composantes controvariantes	 	
  Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // calcul et sauvegarde la base duale

	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai
	 int nbddl = d_gijBB_t.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_t)(i).CoordoB(1).Zero();(*d_giB_t)(i).CoordoB(2).Zero();};
	 if (tCalEpais)  
	     { for (int i=1;i<=nbddl;i++) (*d_giB_t)(i).CoordoB(3).Zero();
	       D_epaisseur_t(phiS);
	     };
  D_a_alpha_B_t(dphiS,nombre_noeud,phiS);  // variation des a_alpha (dans la surface médiane)
  if (tCalEpais)  
     { Cal_d_N_t();  // variation de la normale
       D_a_3_B_t(); // variation de a_3_B
     };
  *d_giB_t = *d_aiB_t;  // pour la suite des calcul dans met_abstraite
  // base duale
     // dans le cas où l'élément est 2D (pas de ddl d'épaisseur),on a uniquement 
     // le calcul de la variation à plat (dans le plan aiB_1 et aiB_2) de aiH, il manque la partie
     // ***** suivant N pour être complet
     // --- par contre dans le cas 3D, le calcul est complet
	 Met_abstraite::D_giH_t();  *d_aiH_t = *d_giH_t;
	 
	 // ----- 2) calcul de la courbure et variation a t ------
	 Dcourbure_t (tab_noeud,curb_t,dcurb_t,tabTypeCL,vplan);
	 Cal_N_alpha_t(); // N,alpha
  Cal_d_N_alpha_t(); // variation de N,alpha

	 //la base a t
	 Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
  // les termes relatif aux gi (et non a la facette)
	 Met_abstraite::Calcul_gijBB_t ();  //      "
	 Met_abstraite::Calcul_gijHH_t ();        // composantes controvariantes
	 Met_abstraite::Calcul_giH_t ();        // base duale
  // les termes de variation des gi
  D_giB_t(dphiS,nombre_noeud,phiH);   // pour les gi
	 Met_abstraite::D_gijBB_t();    //variation de la  metrique en BB
	 Met_abstraite::D_gijBB_t();    //variation de la  metrique en BB
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	     Met_abstraite::Jacobien_t();  // calcul du jacobien a t	 

	 // pour le gradient instannée pour l'instant, pas d'implantation
	 if (gradV_instantane)
	    { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
	      cout << "\n  Met_abstraite::Expli_t_t&  Met_Sfe1::CalSfe1_explicit_t(..." << endl;
	      Sortie(1);
	    };

  // liberation des tenseurs intermediaires
  LibereTenseur();
  // retour des infos
  return ex_expli;
	};   
     // calcul simplifie, a utiliser lorsque l'on se sert des grandeurs
     // liers a la facette deja calculee, ainsi que la courbure
     // cas explicite à t, toutes les grandeurs sont a 0 ou t	
     // gradV_instantane : true : calcul du gradient de vitesse instantannée
     // premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
     //                  false: uniquement les grandeurs à t sont calculées	    
const Met_abstraite::Expli& Met_Sfe1::CalSfe1_explicit_simple_t		         
                 ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & ,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas)
	{if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai
	 int nbddl = d_gijBB_t.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_t)(i).CoordoB(1).Zero();(*d_giB_t)(i).CoordoB(2).Zero();};
	 if (tCalEpais) for (int i=1;i<=nbddl;i++) (*d_giB_t)(i).CoordoB(3).Zero();
	 // normalement ça ne peut pas être un premier calcul
     #ifdef MISE_AU_POINT
	 if (premier_calcul)
	   {cout << "\nErreur : cette fonction n'est pas a etre utilisee lors d'un premier calcul !! ";
     cout << "\n  Met_abstraite::Expli_t_t& Met_Sfe1::CalSfe1_explicit_simple_t(..." << endl;
     Sortie(1);
	   };
     #endif
  // les termes relatif aux gi (et non a la facette)
	 //la base a t
	 Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
	 Met_abstraite::Calcul_gijBB_t ();  //      "
	 Met_abstraite::Calcul_gijHH_t ();        // composantes controvariantes
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
     Met_abstraite::Jacobien_t();         // calcul du jacobien a t
	 Met_abstraite::Calcul_giH_t ();        // base duale
  // les termes de variation des gi
  D_giB_t(dphiS,nombre_noeud,phiH);   // pour les gi
  Met_abstraite::D_gijBB_t();    //variation de la  metrique en BB

	 // pour le gradient instannée pour l'instant, pas d'implantation
	 if (gradV_instantane)
	   { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
	     cout << "\n  Met_abstraite::Expli_t_t&  Met_Sfe1::CalSfe1_explicit_simple_t( ..." << endl;
	     Sortie(1);
	   };

  // liberation des tenseurs intermediaires
  LibereTenseur();
  // retour des infos
  return ex_expli;
	};   
	
// cas explicite à tdt, toutes les grandeurs sont a 0 ou tdt	
// gradV_instantane : true : calcul du gradient de vitesse instantannée 
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
//                  false: uniquement les grandeurs à t+dt sont calculées	    
  const Met_abstraite::Expli_t_tdt&  Met_Sfe1::CalSfe1_explicit_tdt
		         ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur

	 if (premier_calcul)
	   {
      //===== Base a t=0:
      // ------  1) tout d'abord la partie médiane à t = 0	 ------  
         // partie a_alpha
	     Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
	     if (tCalEpais) // cas 3D
            {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_0();                         // la normale 
             Calcul_a_3_B_0();                     // le troisième vecteur 
             };  
	     *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
      // calcul du jacobien de la facette centrale sans courbure
      Met_abstraite::Jacobien_0();         // calcul du jacobien a 0
      ajacobien_0 = jacobien_0; // sauvegarde
      Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0; // metrique base naturelle
      Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0; // composantes controvariantes
      Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde

	     // ----- 2) puis la courbure à t=0 -----
	     // calcul de la coubure a 0
	     curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
	     Cal_N_alpha_0(); // N,alpha

	     // ----- 3) puis la base dans l'épaisseur à t=0 -----
	     //la base a t0
	     Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
      Met_abstraite::Calcul_gijBB_0 ();  // metrique base naturelle
      Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
      Met_abstraite::Calcul_giH_0();
	     if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	          Met_abstraite::Jacobien_0();         // calcul du jacobien a 0

      //===== Base a t:
      // ------  1) tout d'abord la partie médiane à t	= t ------  
	     Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t
	     if (tCalEpais) // cas 3D
            {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées
             Calcul_N_t();                         // la normale 
             Calcul_a_3_B_t();                     // le troisième vecteur 
            };
	     *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
      // calcul du jacobien de la facette centrale sans courbure
      Met_abstraite::Jacobien_t();         // calcul du jacobien a t
      ajacobien_t = jacobien_t; // sauvegarde
      Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t; // metrique base naturelle
      Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t; // composantes controvariantes	 	
      Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // calcul et sauvegarde la base duale
	     // ----- 2) puis la courbure à t = t -----
	     curb_t = courbure_t(tab_noeud,tabTypeCL,vplan);
	     Cal_N_alpha_t(); // N,alpha
	     // ----- 3) puis la base dans l'épaisseur à t = t -----
      //la base a t
      Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
	     if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	          Met_abstraite::Jacobien_t();         // calcul du jacobien a t
      Met_abstraite::Calcul_gijBB_t ();  //   métrique à t
      Met_abstraite::Calcul_gijHH_t ();  // composantes controvariantes à t
	     Met_abstraite::Calcul_giH_t();
    };
	     
  //===== Base a t=t+dt :
	 // ------  1) tout d'abord la partie médiane à t	 ------  
	 Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t+dt
	 if (tCalEpais) // cas 3D
        {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées
         Calcul_N_tdt();                         // la normale 
         Calcul_a_3_B_tdt();                     // le troisième vecteur 
        };
	 *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite

  // calcul du jacobien de la facette centrale sans courbure
  Met_abstraite::Jacobien_tdt();         // calcul du jacobien a tdt
  ajacobien_tdt = jacobien_tdt; // sauvegarde
	 Met_abstraite::Calcul_gijBB_tdt ();  *aijBB_tdt = *gijBB_tdt; // metrique base naturelle
	 Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt; // composantes controvariantes	 	
  Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // calcul et sauvegar de la base duale
  // les termes de variation des ai naturelles et duaux
	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai
	 int nbddl = d_gijBB_tdt.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_tdt)(i).CoordoB(1).Zero();(*d_giB_tdt)(i).CoordoB(2).Zero();};
	 if (tCalEpais)  
	     { for (int i=1;i<=nbddl;i++) (*d_giB_tdt)(i).CoordoB(3).Zero();
	       D_epaisseur_tdt(phiS);
	     };
  D_a_alpha_B_tdt(dphiS,nombre_noeud,phiS);  // variation des a_alpha (dans la surface médiane)
  if (tCalEpais)  
     { Cal_d_N_tdt();  // variation de la normale
       D_a_3_B_tdt(); // variation de a_3_B
     };
  *d_giB_tdt = *d_aiB_tdt;  // pour la suite des calcul dans met_abstraite
  // base duale
     // dans le cas où l'élément est 2D (pas de ddl d'épaisseur),on a uniquement 
     // le calcul de la variation à plat (dans le plan aiB_1 et aiB_2) de aiH, il manque la partie
     // ***** suivant N pour être complet
     // --- par contre dans le cas 3D, le calcul est complet
	 Met_abstraite::D_giH_tdt();  *d_aiH_tdt = *d_giH_tdt;
	 
	 // ----- 2) calcul de la coubure et variation a t+dt ------
	 Dcourbure_tdt (tab_noeud,curb_tdt,dcurb_tdt,tabTypeCL,vplan);
	 Cal_N_alpha_tdt(); // N,alpha
  Cal_d_N_alpha_tdt(); // variation de N,alpha
          
	 // ----- 3)  bases  dans l'épaisseur et leur variation à t = t + dt  -----
	 //la base a tdt
	 Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
	 Met_abstraite::Calcul_gijBB_tdt ();  //      "
	 Met_abstraite::Calcul_gijHH_tdt ();        // composantes controvariantes
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure
	     Met_abstraite::Jacobien_tdt();  // calcul du jacobien a tdt	 
	 Met_abstraite::Calcul_giH_tdt();        // base duale
  // les termes de variation des gi
  D_giB_tdt(dphiS,nombre_noeud,phiH);   // pour les gi
	 Met_abstraite::D_gijBB_tdt();    //variation de la  metrique en BB
	 // pour le gradient instannée pour l'instant, pas d'implantation
	 if (gradV_instantane)
	    { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
	      cout << "\n  Met_abstraite::Expli_t_tdt&  Met_Sfe1::CalSfe1_explicit_tdt..." << endl;
	      Sortie(1);
	    };
  // liberation des tenseurs intermediaires
  LibereTenseur();
	 // retour des infos
  return ex_expli_t_tdt;
	}; 
	  
// calcul simplifie à tdt, a utiliser lorsque l'on se sert des grandeurs
// liers a la facette deja calculee, ainsi que la courbure
// cas explicite à tdt, toutes les grandeurs sont a 0 ou tdt	
// gradV_instantane : true : calcul du gradient de vitesse instantannée 
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
//                  false: uniquement les grandeurs à t sont calculées	    
const Met_abstraite::Expli_t_tdt& Met_Sfe1::CalSfe1_explicit_simple_tdt
		         ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & ,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas)
	{if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai
	 int nbddl = d_gijBB_tdt.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_tdt)(i).CoordoB(1).Zero();(*d_giB_tdt)(i).CoordoB(2).Zero();};
	 if (tCalEpais) for (int i=1;i<=nbddl;i++) (*d_giB_tdt)(i).CoordoB(3).Zero();
	 // normalement ça ne peut pas être un premier calcul
  #ifdef MISE_AU_POINT
	 if (premier_calcul)
	   {cout << "\nErreur : cette fonction n'est pas a etre utilisee lors d'un premier calcul !! ";
     cout << "\n  Met_abstraite::Expli_t_tdt& Met_Sfe1::CalSfe1_explicit_simple_tdt(..." << endl;
     Sortie(1);
	   };
  #endif
	     
	 //la base a tdt
	 Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
  // les termes relatif aux gi (et non a la facette)
	 Met_abstraite::Calcul_gijBB_tdt ();  //      "
	 Met_abstraite::Calcul_gijHH_tdt ();        // composantes controvariantes
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure
	     Met_abstraite::Jacobien_tdt();  // calcul du jacobien a tdt	 
	 Met_abstraite::Calcul_giH_tdt();        // base duale
  // les termes de variation  des gi
  	 D_giB_tdt(dphiS,nombre_noeud,phiH);   // pour les gi
	 Met_abstraite::D_gijBB_tdt();    //variation de la  metrique en BB

	 // pour le gradient instannée pour l'instant, pas d'implantation
	 if (gradV_instantane)
	    { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
	      cout << "\n  Met_abstraite::Expli_t_tdt&  Met_Sfe1::CalSfe1_explicit_simple_tdt( ..." << endl;
	      Sortie(1);
	    };

  // liberation des tenseurs intermediaires
  LibereTenseur();   
  return ex_expli_t_tdt;
	};   
		
// cas implicite, toutes les grandeurs sont a 0 ou t+dt	
	 // gradV_instantane : true : calcul du gradient de vitesse instantannée 
     // premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
     //                  false: uniquement les grandeurs à t sont calculées	    
const Met_abstraite::Impli& Met_Sfe1::CalSfe1_implicit
		         ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	 
	 if (premier_calcul)
	   {
      //===== Base a t=0:
      // ------  1) tout d'abord la partie médiane à t = 0	 ------  
         // partie a_alpha
	     Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
	     if (tCalEpais) // cas 3D
            {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_0();                         // la normale 
             Calcul_a_3_B_0();                     // le troisième vecteur 
            };
	     *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
      // calcul du jacobien de la facette centrale sans courbure
      Met_abstraite::Jacobien_0();         // calcul du jacobien a 0
      ajacobien_0 = jacobien_0; // sauvegarde
	     Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
	     Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
      Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde

	   // ----- 2) puis la courbure à t=0 -----
	     // calcul de la coubure a 0
	     curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
	     Cal_N_alpha_0(); // N,alpha
	   // ----- 3) puis la base dans l'épaisseur à t=0 -----
	     //la base a t0
	     Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
	     Met_abstraite::Calcul_gijBB_0 ();    //      "
	     Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
      Met_abstraite::Calcul_giH_0(); 
	     if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	          Met_abstraite::Jacobien_0();         // calcul du jacobien a 0

	   //===== Base a t:
	   // ------  1) tout d'abord la partie médiane à t	= t ------  
	     Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t
	     if (tCalEpais) // cas 3D
            {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées
             Calcul_N_t();                         // la normale 
             Calcul_a_3_B_t();                     // le troisième vecteur 
             }; 
	     *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
      // calcul du jacobien de la facette centrale sans courbure
      Met_abstraite::Jacobien_t();         // calcul du jacobien a t
      ajacobien_t = jacobien_t; // sauvegarde
	     Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t;   // metrique base naturelle
	     Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t; // composantes controvariantes	 	
      Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // calcul et sauvegarde de la base duale
	   // ----- 2) puis la courbure à t = t -----
	     curb_t = courbure_t(tab_noeud,tabTypeCL,vplan);
	     Cal_N_alpha_t(); // N,alpha
	   // ----- 3) puis la base dans l'épaisseur à t = t -----
	     //la base a t
	     Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
	     if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	          Met_abstraite::Jacobien_t();         // calcul du jacobien a t
	     Met_abstraite::Calcul_gijBB_t();
	     Met_abstraite::Calcul_gijHH_t();
	     Met_abstraite::Calcul_giH_t();
	   };

 //===== Base a t=t+dt :
	 // ------  1) tout d'abord la partie médiane à tdt	 ------  
	 Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t+dt
	 if (tCalEpais) // cas 3D
        {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées
         Calcul_N_tdt();                         // la normale 
         Calcul_a_3_B_tdt();                     // le troisième vecteur 
         };  
	 *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
  // calcul du jacobien de la facette centrale sans courbure
  Met_abstraite::Jacobien_tdt();         // calcul du jacobien a tdt
  ajacobien_tdt = jacobien_tdt; // sauvegarde
	 Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt; // metrique base naturelle
	 Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt; // composantes controvariantes	 	
  Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // calcul et sauvegarde la base duale

  // --- les termes de variation des ai naturelles et duaux
	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai (effacement des variations externes de l'appel précédent)
	 int nbddl = d_gijBB_tdt.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_tdt)(i).CoordoB(1).Zero();(*d_giB_tdt)(i).CoordoB(2).Zero();};
//	      (*d_aiB_tdt)(i)(1).Zero();(*d_aiB_tdt)(i)(2).Zero();
	 if (tCalEpais)  
	     { for (int i=1;i<=nbddl;i++) (*d_giB_tdt)(i).CoordoB(3).Zero();
	       D_epaisseur_tdt(phiS);
	     };
  D_a_alpha_B_tdt(dphiS,nombre_noeud,phiS);  // variation des a_alpha (dans la surface médiane)
  if (tCalEpais)  
     { Cal_d_N_tdt();  // variation de la normale
       D_a_3_B_tdt(); // variation de a_3_B
     };
  *d_giB_tdt = *d_aiB_tdt;  // pour la suite des calcul dans met_abstraite
  // base duale
     // dans le cas où l'élément est 2D (pas de ddl d'épaisseur),on a uniquement 
     // le calcul de la variation à plat (dans le plan aiB_1 et aiB_2) de aiH, il manque la partie
     // ***** suivant N pour être complet
     // --- par contre dans le cas 3D, le calcul est complet
	 Met_abstraite::D_giH_tdt();  *d_aiH_tdt = *d_giH_tdt;
	 if (type_calcul_jacobien==1) // cas où on utilise la variation du jacobien de la surface sans courbure
	    {  Met_abstraite::Djacobien_tdt();    // variation du jacobien
        d_ajacobien_tdt = d_jacobien_tdt;
	    };
	 
	 // ----- 2) calcul de la coubure et variation a t+dt ------
	 Dcourbure_tdt (tab_noeud,curb_tdt,dcurb_tdt,tabTypeCL,vplan);
	 Cal_N_alpha_tdt(); // N,alpha
  Cal_d_N_alpha_tdt(); // variation de N,alpha
          
// ----- programme de vérification par différences finies des dérivées ---------
//     Mat_pleine tabdphiH; // ne sert à rien
//     Verif_Dcourbure(tab_noeud,gradV_instantane,dphiS,nombre_noeud,phiS
//                    ,tabdphiH,phiH,epas,tabTypeCL,vplan);
// ----- fin programme de vérification par différences finies des dérivées ------

	 // ----- 3)  bases  dans l'épaisseur et leur variation à t = t + dt  -----
	 //la base a tdt
	 Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
  // les termes relatif aux gi (et non a la facette)
	 Met_abstraite::Calcul_gijBB_tdt ();  //      "
	 Met_abstraite::Calcul_gijHH_tdt ();        // composantes controvariantes
  // les termes de variation des  gi
  D_giB_tdt(dphiS,nombre_noeud,phiH);   // calcul des variations  / "tous" les ddl
	 Met_abstraite::D_gijBB_tdt();    //variation de la  metrique en BB
	 Met_abstraite::Calcul_giH_tdt();    // base duale
	 Met_abstraite::D_giH_tdt();         // variation de la base duale
	 Met_abstraite::D_gijHH_tdt();    //variation de la  metrique en HH
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface avec courbure finale
	    { Met_abstraite::Jacobien_tdt();  // calcul du jacobien a tdt	 
	      Met_abstraite::Djacobien_tdt();    // variation du jacobien 
	    };
	 // pour le gradient instannée pour l'instant, pas d'implantation
	 if (gradV_instantane)
	    { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
	      cout << "\n  Met_abstraite::Expli_t_tdt&  Met_Sfe1::CalSfe1_explicit_tdt..." << endl;
	      Sortie(1);
	    };
  LibereTenseur();
	 // retour des infos
	 return ex_impli;
	};
	
// calcul simplifie, a utiliser lorsque l'on se sert des grandeurs
// liées a la facette deja calculee, ainsi que la courbure et sa variation
// cas implicite, toutes les grandeurs sont a 0 ou t+dt	
	 // gradV_instantane : true : calcul du gradient de vitesse instantannée 
     // premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
     //                  false: uniquement les grandeurs à t sont calculées	    
const Met_abstraite::Impli& Met_Sfe1::CalSfe1_implicit_simple
		         ( const Tableau<Noeud *>& tab_noeud
		          ,bool gradV_instantane,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & ,bool premier_calcul
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas)
	{if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	 // initialisation des variations par rapport aux ddl externes pour tous les termes
	 // relatif a la base ai
	 int nbddl = d_gijBB_tdt.Taille();
	 for (int i=1;i<=nbddl;i++)
	    { (*d_giB_tdt)(i).CoordoB(1).Zero();(*d_giB_tdt)(i).CoordoB(2).Zero();};
	 if (tCalEpais) for (int i=1;i<=nbddl;i++) (*d_giB_tdt)(i).CoordoB(3).Zero();

	 // normalement ça ne peut pas être un premier calcul
  #ifdef MISE_AU_POINT
	 if (premier_calcul)
	   {cout << "\nErreur : cette fonction n'est pas a etre utilisee lors d'un premier calcul !! ";
		cout << "\n  Met_abstraite::Impli& Met_Sfe1::CalSfe1_implicit_simple(..." << endl;
		Sortie(1);
	   };
  #endif

	 //la base a tdt
	 Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
  // les termes relatif aux gi (et non a la facette)
	 Met_abstraite::Calcul_gijBB_tdt ();  //      "
	 Met_abstraite::Calcul_gijHH_tdt ();        // composantes controvariantes
	 Met_abstraite::Calcul_giH_tdt();     // base duale
  // les termes de variation des  gi
  	 D_giB_tdt(dphiS,nombre_noeud,phiH);   // pour les gi
	 Met_abstraite::D_gijBB_tdt();    //variation de la  metrique en BB
	 Met_abstraite::D_giH_tdt();         // variation de la base duale
	 Met_abstraite::D_gijHH_tdt();    //variation de la  metrique en HH
	 if (type_calcul_jacobien==2) // cas où on utilise le jacobien de la surface sans courbure
	    { Met_abstraite::Jacobien_tdt();  // calcul du jacobien a tdt	 
	      Met_abstraite::Djacobien_tdt();    // variation du jacobien 
	    };
  // pour le gradient instannée pour l'instant, pas d'implantation
  if (gradV_instantane)
	    { cout << "\nErreur : pas de  calcul du gradient instantanne pour l'instant avec la metrique SFE";
		     cout << "\n  Met_abstraite::Impli& Met_Sfe1::CalSfe1_implicit_simple(..." << endl;
	      Sortie(1);
	    };
  // liberation des tenseurs intermediaires
  LibereTenseur();
	 // retour des infos
	 return ex_impli;
	};
	
// --------------- cas du calcul pour la matrice masse --------------------	
	
		// calcul pour la matrice masse: 
  // dans le cas des SFE, on ne calcul que sur la surface centrale, et pour
const Met_abstraite::Dynamiq& Met_Sfe1::Cal_pourMatMass
              ( const  Tableau<Noeud *>& tab_noeud, const  Mat_pleine& dphiS, 
              int nombre_noeud,const Vecteur& phiS)
  {  //===== Base a t=0:
     Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
     Calcul_N_0();   
     if (tCalEpais) // cas 3D
        {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
         Calcul_a_3_B_0();                     // le troisième vecteur 
         };  
     *giB_0 = *aiB_0;  // pour le stockage éventuel
     Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // idem
	    Met_abstraite::Jacobien_0();   // jacobien initiale
     ajacobien_0 = jacobien_0; // sauvegarde
     // liberation des tenseurs intermediaires
     LibereTenseur();   
	    return ex_Dynamiq;
	 };

// --------------- test sur la courbure ------------------------------
  // test si la courbure est anormalement trop grande
  // inf_normale : indique en entrée le det mini pour la courbure en locale
  // retour 1:  si tout est ok,
  //        0:  une courbure trop grande a été détecté
int Met_Sfe1::Test_courbure_anormale
                  (Enum_dure temps,double inf_normale, const  Tableau<Noeud *>& tab_noeud
                   ,const  Mat_pleine& dphiS,int nombre_noeud,const Vecteur& phiS)
  {
    int retour = 1; // init par défaut
    switch (temps)
      {case TEMPS_0 :
        { //===== Base a t=0:
          // ------  1) tout d'abord la partie médiane à t = 0	 ------
          // partie a_alpha
	         Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
	         if (tCalEpais) // cas 3D
            {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_0();                         // la normale 
             Calcul_a_3_B_0();                     // le troisième vecteur 
            };
	         *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
          // calcul du jacobien de la facette centrale sans courbure
          Met_abstraite::Jacobien_0();         // calcul du jacobien a 0
          ajacobien_0 = jacobien_0; // sauvegarde

          Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
          Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
          Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
          Tableau<Coordonnee3> tab_coor(6);
          for (int i=1;i<=6;i++)
            tab_coor(i) = tab_noeud(i)->Coord0();
          retour = (this->*PtTest_courbure_anormale)(inf_normale,tab_coor,(*aiB_0),(*aiH_0));
          break;
        }
       case TEMPS_t :
        { // ------  la partie médiane à t	= t ------
          Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t
          if (tCalEpais) // cas 3D
             {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées
              Calcul_N_t();                         // la normale 
              Calcul_a_3_B_t();                     // le troisième vecteur 
             };
          *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
          // calcul du jacobien de la facette centrale sans courbure
          Met_abstraite::Jacobien_t();         // calcul du jacobien a t
          ajacobien_t = jacobien_t; // sauvegarde
          Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t;   // metrique base naturelle
          Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t; // composantes controvariantes	 	
          Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // calcul et sauvegarde de la base duale
          Tableau<Coordonnee3> tab_coor(6);
          for (int i=1;i<=6;i++)
            tab_coor(i) = tab_noeud(i)->Coord1();
          retour = (this->*PtTest_courbure_anormale)(inf_normale,tab_coor,(*aiB_t),(*aiH_t));
          break;
        }
       case TEMPS_tdt :
        { // ------  la partie médiane à t+dt	 ------
          Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a tdt
          if (tCalEpais) // cas 3D
             {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées
              Calcul_N_tdt();                         // la normale
              Calcul_a_3_B_tdt();                     // le troisième vecteur
             };
          *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
          // calcul du jacobien de la facette centrale sans courbure
          Met_abstraite::Jacobien_tdt();         // calcul du jacobien a tdt
          ajacobien_tdt = jacobien_tdt; // sauvegarde
          Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt;   // metrique base naturelle
          Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt; // composantes controvariantes
          Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // calcul et sauvegarde de la base duale
          Tableau<Coordonnee3> tab_coor(6);
          for (int i=1;i<=6;i++)
            tab_coor(i) = tab_noeud(i)->Coord2();
          retour = (this->*PtTest_courbure_anormale)(inf_normale,tab_coor,(*aiB_tdt),(*aiH_tdt));
          break;
        }
       default :
        cout << "\nErreur : valeur incorrecte du type Enum_dure : = "
             << Nom_dure(temps) <<" !\n";
        cout << "\n Met_Sfe1::Test_courbure_anormale(... \n";
        Sortie(1);
      };
    // retour
    return retour;
  };

 //-------- pour la remontee aux infos duaux ------------	
const Met_abstraite::InfoImp& Met_Sfe1::CalSfe1_InfoImp
		         ( const Tableau<Noeud *>& tab_noeud
		          ,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS 
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{ if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	  // Base et point a t=0 : tout d'abord on calcul les elements relatifs a la facette plane
	  Met_abstraite::Calcul_M0(tab_noeud,phiS,nombre_noeud); *P0 = *M0;
	 
// pour toutes les grandeurs à 0, on les a sauvegardé dans Deformation donc on ne devrait pas les re-
// calculer, là il y a des économies de temps à faire
// et il y a plein de chose qui sont calculé que je met en commentaire car on se demande à quoi ça sert	 
	 
   //===== Base a t=0:
   // ------  1) tout d'abord la partie médiane à t = 0	 ------  
   Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
   Calcul_N_0();    // la normale est nécessaire pour le calcul de M0 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_0();                     // le troisième vecteur 
      };
   *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
   Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
   // ----- 2) puis la courbure à t=0 -----
   curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_0(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=0 -----
   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_0 ();    //      "
   Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
   Met_abstraite::Calcul_giH_0();
	  Calcul_M0(tab_noeud,phiH,nombre_noeud);

   //===== Base a t=tdt:
	  Met_abstraite::Calcul_Mtdt(tab_noeud,phiS,nombre_noeud); *Ptdt = *Mtdt;
   // ------  1) tout d'abord la partie médiane à t = t	+ dt ------  
   Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= tdt
   Calcul_N_tdt();    // la normale est nécessaire pour le calcul de Mtdt 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_tdt();                     // le troisième vecteur 
      };
   *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt;  // composantes controvariantes
   Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // sauvegarde
   // ----- 2) puis la courbure à t=tdt -----
   curb_tdt = courbure_tdt(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_tdt(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=tdt -----
   Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_tdt ();    //      "
   Met_abstraite::Calcul_gijHH_tdt ();  // composantes controvariantes à tdt
   Met_abstraite::Calcul_giH_tdt();
	  Calcul_Mtdt(tab_noeud,phiH,nombre_noeud);
	 
	  // retour des infos
   // liberation des tenseurs intermediaires
   LibereTenseur();   
   return ex_InfoImp;
 };
   
const Met_abstraite::InfoExp_t& Met_Sfe1::CalSfe1_InfoExp_t
		         ( const Tableau<Noeud *>& tab_noeud
		          ,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{ if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur

	  Met_abstraite::Calcul_M0(tab_noeud,phiS,nombre_noeud); *P0 = *M0;
	 
// pour toutes les grandeurs à 0, on les a sauvegardé dans Deformation donc on ne devrait pas les re-
// calculer, là il y a des économies de temps à faire
// et il y a plein de chose qui sont calculé que je met en commentaire car on se demande à quoi ça sert	 
	 
   //===== Base a t=0:
   // ------  1) tout d'abord la partie médiane à t = 0	 ------  
   Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
   Calcul_N_0();    // la normale est nécessaire pour le calcul de M0 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_0();                     // le troisième vecteur 
       };  
   *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
   Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
   // ----- 2) puis la courbure à t=0 -----
   curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_0(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=0 -----
   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_0 ();    //      "
   Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
   Met_abstraite::Calcul_giH_0();
	  Calcul_M0(tab_noeud,phiH,nombre_noeud);

   //===== Base a t=t:
	  Met_abstraite::Calcul_Mt(tab_noeud,phiS,nombre_noeud); *Pt = *Mt;
   // ------  1) tout d'abord la partie médiane à t = t	 ------  
   Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= t
   Calcul_N_t();    // la normale est nécessaire pour le calcul de Mt 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_t();                     // le troisième vecteur 
       };  
   *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t;  // composantes controvariantes
   Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // sauvegarde
   // ----- 2) puis la courbure à t=t -----
   curb_t = courbure_t(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_t(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=t -----
   Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_t ();    //      "
   Met_abstraite::Calcul_gijHH_t ();  // composantes controvariantes à t
   Met_abstraite::Calcul_giH_t();
	  Calcul_Mt(tab_noeud,phiH,nombre_noeud);

	  // retour des infos
   // liberation des tenseurs intermediaires
   LibereTenseur();   
   return ex_InfoExp_t;
 };
      
   
const Met_abstraite::InfoExp_tdt& Met_Sfe1::CalSfe1_InfoExp_tdt
		         ( const Tableau<Noeud *>& tab_noeud
		          ,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{ if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
	  // Base et point a t=0 : tout d'abord on calcul les elements relatifs a la facette plane
	  Met_abstraite::Calcul_M0(tab_noeud,phiS,nombre_noeud); *P0 = *M0;

	 
// pour toutes les grandeurs à 0, on les a sauvegardé dans Deformation donc on ne devrait pas les re-
// calculer, là il y a des économies de temps à faire
// et il y a plein de chose qui sont calculé que je met en commentaire car on se demande à quoi ça sert	 
	 
   //===== Base a t=0:
   // ------  1) tout d'abord la partie médiane à t = 0	 ------  
   Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
   Calcul_N_0();    // la normale est nécessaire pour le calcul de M0 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_0();                     // le troisième vecteur 
       };  
   *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
   Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
   // ----- 2) puis la courbure à t=0 -----
   curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_0(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=0 -----
   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_0 ();    //      "
   Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
   Met_abstraite::Calcul_giH_0();
	  Calcul_M0(tab_noeud,phiH,nombre_noeud);

   //===== Base a t=tdt:
	  Met_abstraite::Calcul_Mtdt(tab_noeud,phiS,nombre_noeud); *Ptdt = *Mtdt;
   // ------  1) tout d'abord la partie médiane à t = t	+ dt ------  
   Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= tdt
   Calcul_N_tdt();    // la normale est nécessaire pour le calcul de Mtdt 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_tdt();                     // le troisième vecteur 
       };  
   *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt;  // composantes controvariantes
   Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // sauvegarde
   // ----- 2) puis la courbure à t=tdt -----
   curb_tdt = courbure_tdt(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_tdt(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=tdt -----
   Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_tdt ();    //      "
   Met_abstraite::Calcul_gijHH_tdt ();  // composantes controvariantes à tdt
   Met_abstraite::Calcul_giH_tdt();
	  Calcul_Mtdt(tab_noeud,phiH,nombre_noeud);

   // liberation des tenseurs intermediaires
   LibereTenseur();
	  // retour des infos
   return ex_InfoExp_tdt;
 };
      
      
// cas sortie d'info à 0 t et tdt: point, giB, giH,
// calcul des termes de la classe Info0_t_tdt 	
const Met_abstraite::Info0_t_tdt& Met_Sfe1::CalSfe1_Info0_t_tdt
		         ( const Tableau<Noeud *>& tab_noeud
		          ,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
	{ if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
   // Base et point a t=0 : tout d'abord on calcul les elements relatifs a la facette plane
   Met_abstraite::Calcul_M0(tab_noeud,phiS,nombre_noeud); *P0 = *M0;

	 
// pour toutes les grandeurs à 0, on les a sauvegardé dans Deformation donc on ne devrait pas les re-
// calculer, là il y a des économies de temps à faire
// et il y a plein de chose qui sont calculé que je met en commentaire car on se demande à quoi ça sert	 
	 
   //===== Base a t=0:
   // ------  1) tout d'abord la partie médiane à t = 0	 ------  
   Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
   Calcul_N_0();    // la normale est nécessaire pour le calcul de M0 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_0();                     // le troisième vecteur 
       };  
   *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
   Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
   // ----- 2) puis la courbure à t=0 -----
     curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
     Cal_N_alpha_0(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=0 -----
   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_0 ();    //      "
   Met_abstraite::Calcul_gijHH_0 ();  // composantes controvariantes à 0
   Met_abstraite::Calcul_giH_0();
	  Calcul_M0(tab_noeud,phiH,nombre_noeud);

   //===== Base a t=t:
	  Met_abstraite::Calcul_Mt(tab_noeud,phiS,nombre_noeud); *Pt = *Mt;
   // ------  1) tout d'abord la partie médiane à t = t	 ------  
   Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= t
   Calcul_N_t();    // la normale est nécessaire pour le calcul de Mt 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_t();                     // le troisième vecteur 
       };  
   *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t;  // composantes controvariantes
   Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // sauvegarde
   // ----- 2) puis la courbure à t=t -----
   curb_t = courbure_t(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_t(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=t -----
   Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_t ();    //      "
   Met_abstraite::Calcul_gijHH_t ();  // composantes controvariantes à t
   Met_abstraite::Calcul_giH_t();
	  Calcul_Mt(tab_noeud,phiH,nombre_noeud);

   //===== Base a t=tdt:
	  Met_abstraite::Calcul_Mtdt(tab_noeud,phiS,nombre_noeud); *Ptdt = *Mtdt;
   // ------  1) tout d'abord la partie médiane à t = t	+ dt ------  
   Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= tdt
   Calcul_N_tdt();    // la normale est nécessaire pour le calcul de Mtdt 
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_a_3_B_tdt();                     // le troisième vecteur 
       };  
   *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt;  // composantes controvariantes
   Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // sauvegarde
   // ----- 2) puis la courbure à t=tdt -----
   curb_tdt = courbure_tdt(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_tdt(); // N,alpha
   // ----- 3) puis la base dans l'épaisseur à t=tdt -----
   Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_tdt ();    //      "
   Met_abstraite::Calcul_gijHH_tdt ();  // composantes controvariantes à tdt
   Met_abstraite::Calcul_giH_tdt();
	  Calcul_Mtdt(tab_noeud,phiH,nombre_noeud);

   // liberation des tenseurs intermediaires
   LibereTenseur();
	  // retour des infos
   return ex_Info0_t_tdt;
 };

// cas du calcul de la déformation d'Almansi uniquement
const Met_abstraite::Pour_def_Almansi Met_Sfe1::CalSfe1_pour_def_Almansi_au_temps
		         ( Enum_dure temps,const Tableau<Noeud *>& tab_noeud
		          ,Mat_pleine const & dphiS,int nombre_noeud
		          ,Vecteur const & phiS
		          ,Mat_pleine const & ,Vecteur const& phiH,const Epai* epas
		          ,Tableau <EnuTypeCL> const & tabTypeCL,Tableau <Coordonnee3> const & vplan)
  {if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
   Met_abstraite::Pour_def_Almansi pdamsi;
   	 
// pour toutes les grandeurs à 0, on les a sauvegardé dans Deformation donc on ne devrait pas les re-
// calculer, là il y a des économies de temps à faire
// et il y a plein de chose qui sont calculé que je met en commentaire car on se demande à quoi ça sert	 
	 
 //===== Base a t=0:
 // ------  1) tout d'abord la partie médiane à t = 0	 ------  
   Calcul_a_alpha_B_0(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t=0
   if (tCalEpais) // cas 3D
      {Calcul_epaisseur_0(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
       Calcul_N_0();                         // la normale 
       Calcul_a_3_B_0();                     // le troisième vecteur 
      };  
   *giB_0 = *aiB_0;  // pour la suite des calcul dans met_abstraite
   Met_abstraite::Calcul_gijBB_0 (); *aijBB_0 = *gijBB_0;  // metrique base naturelle en tenseur 2D
   Met_abstraite::Calcul_gijHH_0 (); *aijHH_0 = *gijHH_0;  // composantes controvariantes
   Met_abstraite::Calcul_giH_0(); *aiH_0 = *giH_0; // sauvegarde
 // ----- 2) puis la courbure à t=0 -----
   curb_0 = courbure_0(tab_noeud,tabTypeCL,vplan);
   Cal_N_alpha_0(); // N,alpha
 // ----- 3) puis la base dans l'épaisseur à t=0 -----
   Calcul_giB_0(tab_noeud,dphiS,nombre_noeud,phiH);
   Met_abstraite::Calcul_gijBB_0 ();    //      "
   pdamsi.gijBB_0=gijBB_0;
   switch (temps)
    { case TEMPS_t:
       {// ------  1) tout d'abord la partie médiane à t = t	 ------  
         Calcul_a_alpha_B_t(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= t
         if (tCalEpais) // cas 3D
            {Calcul_epaisseur_t(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_t();                         // la normale 
             Calcul_a_3_B_t();                     // le troisième vecteur 
             };  
         *giB_t = *aiB_t;  // pour la suite des calcul dans met_abstraite
         Met_abstraite::Calcul_gijBB_t (); *aijBB_t = *gijBB_t;  // metrique base naturelle en tenseur 2D
         Met_abstraite::Calcul_gijHH_t (); *aijHH_t = *gijHH_t;  // composantes controvariantes
         Met_abstraite::Calcul_giH_t(); *aiH_t = *giH_t; // sauvegarde
       // ----- 2) puis la courbure à t=t -----
         curb_t = courbure_t(tab_noeud,tabTypeCL,vplan);
         Cal_N_alpha_t(); // N,alpha
       // ----- 3) puis la base dans l'épaisseur à t=t -----
         Calcul_giB_t(tab_noeud,dphiS,nombre_noeud,phiH);
         Met_abstraite::Calcul_gijBB_t ();    //      "
         pdamsi.gijBB=gijBB_t;
	     break;
	    }
	  case TEMPS_tdt:    
       {// ------  1) tout d'abord la partie médiane à t = t	+ dt ------  
         Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nombre_noeud,phiS); // calcul de la base a t= tdt
         if (tCalEpais) // cas 3D
            {Calcul_epaisseur_tdt(tab_noeud,phiS);   // calcul des épaisseurs interpolées 
             Calcul_N_tdt();                         // la normale 
             Calcul_a_3_B_tdt();                     // le troisième vecteur 
             };  
         *giB_tdt = *aiB_tdt;  // pour la suite des calcul dans met_abstraite
         Met_abstraite::Calcul_gijBB_tdt (); *aijBB_tdt = *gijBB_tdt;  // metrique base naturelle en tenseur 2D
         Met_abstraite::Calcul_gijHH_tdt (); *aijHH_tdt = *gijHH_tdt;  // composantes controvariantes
         Met_abstraite::Calcul_giH_tdt(); *aiH_tdt = *giH_tdt; // sauvegarde
       // ----- 2) puis la courbure à t=tdt -----
         curb_tdt = courbure_tdt(tab_noeud,tabTypeCL,vplan);
         Cal_N_alpha_tdt(); // N,alpha
       // ----- 3) puis la base dans l'épaisseur à t=tdt -----
         Calcul_giB_tdt(tab_noeud,dphiS,nombre_noeud,phiH);
         Met_abstraite::Calcul_gijBB_tdt ();    //      "
         pdamsi.gijBB=gijBB_tdt;
	     break;
	    }
	  };  
  return pdamsi;
  }; 

// cas du calcul de la déformation logarithmique uniquement
const Met_abstraite::Pour_def_log Met_Sfe1::CalSfe1_pour_def_log_au_temps
		         ( Enum_dure ,const Tableau<Noeud *>& 
		          ,Mat_pleine const & ,int 
		          ,Vecteur const & 
		          ,Mat_pleine const & ,Vecteur const& 
		          ,const Epai*   
		          ,Tableau <EnuTypeCL> const & ,Tableau <Coordonnee3> const & )
               {cout << "\n erreur, calcul non fonctionnelle !! "
		     	         << "\n Met_abstraite::Pour_def_log Met_Sfe1::CalSfe1_pour_def_log_au_temps(.." << endl;
		     	    Sortie(1);     
		     		// pour l'instant rien
		     		Met_abstraite::Pour_def_log toto;

		     		return toto;
		     	}; 
            
// ========== utilise par le contact =========================

// calcul d'un point M0  en fonction des phi et des coordonnees a 0
const Coordonnee & Met_Sfe1::PointSfe1M_0 // ( stockage a t=0)
		  ( const Tableau<Noeud *>& tab_noeud, const Vecteur& phiS,Mat_pleine const & dphiS
		   ,const Epai* epas, const Vecteur& phiH)
   {if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
    else {Calcul_epaisseur_0(tab_noeud,phiS);}; // sinon on calcul l'interpolation       
	Met_abstraite::Calcul_M0(tab_noeud,phiS,nomb_noeud); *P0 = *M0; // le point de la surface médiane
    Calcul_a_alpha_B_0(tab_noeud,dphiS,nomb_noeud,phiS); // calcul de la base a t=0
    Calcul_N_0();                         // la normale 
    Calcul_M0(tab_noeud,phiH,nomb_noeud);	// là on utilise l'épaisseur calculée ou récupérée
    return *M0;
   };

// calcul d'un point M  en fonction des phi et des coordonnees a t
const Coordonnee & Met_Sfe1::PointSfe1M_t // ( stockage a t)
		  ( const Tableau<Noeud *>& tab_noeud, const Vecteur& phiS,Mat_pleine const & dphiS
		   ,const Epai* epas, const Vecteur& phiH)
   {if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
    else {Calcul_epaisseur_t(tab_noeud,phiS);}; // sinon on calcul l'interpolation       
	Met_abstraite::Calcul_Mt(tab_noeud,phiS,nomb_noeud); *Pt = *Mt; // le point de la surface médiane
    Calcul_a_alpha_B_t(tab_noeud,dphiS,nomb_noeud,phiS); // calcul de la base a t=t
    Calcul_N_t ();     
    Calcul_Mt(tab_noeud,phiH,nomb_noeud);	// là on utilise l'épaisseur calculée ou récupérée	
    return *Mt;
   };
/*   
// calcul de la variation d'un point M  par rapport aux ddl , 
// en fonction des phi et des coordonnees a t
const Tableau<Coordonnee> & Met_Sfe1::D_PointSfe1M_t // ( stockage a t)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
  { Calcul_d_Mt(tab_noeud,Phi,nomb_noeud);
    return *d_Mt;
   };
*/		  

// calcul d'un point M  en fonction des phi et des coordonnees a tdt
const Coordonnee & Met_Sfe1::PointSfe1M_tdt // ( stockage a tdt)
		  ( const Tableau<Noeud *>& tab_noeud, const Vecteur& phiS,Mat_pleine const & dphiS
		   ,const Epai* epas, const Vecteur& phiH)
   {if ((epas != NULL)&&(!tCalEpais)) epais = *epas; // récup éventuelle de l'épaisseur
    else {Calcul_epaisseur_tdt(tab_noeud,phiS);}; // sinon on calcul l'interpolation       
	Met_abstraite::Calcul_Mtdt(tab_noeud,phiS,nomb_noeud); *Ptdt = *Mtdt; // le point de la surface médiane
    Calcul_a_alpha_B_tdt(tab_noeud,dphiS,nomb_noeud,phiS); // calcul de la base a t=tdt
    Calcul_N_tdt ();     
    Calcul_Mtdt(tab_noeud,phiH,nomb_noeud);	 // là on utilise l'épaisseur calculée ou récupérée
    return *Mtdt;
   };
/*   
// calcul de la variation d'un point M  par rapport aux ddl , 
// en fonction de phis et des coordonnees a tdt
const Tableau<Coordonnee> & Met_Sfe1::D_PointSfe1M_tdt // ( stockage a tdt)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
  { Calcul_d_Mtdt(tab_noeud,Phi,nomb_noeud);
    return *d_Mtdt;
   };

// calcul de la vitesse du point M en fonction de phi et des coordonnees a 0
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t 
const Coordonnee & Met_Sfe1::VitesseSfe1M_0 // ( stockage a t=0)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
  { if (tab_noeud(1)->Existe_ici(V1))
      { Calcul_V0(tab_noeud,Phi,nomb_noeud); }
    else 
      { Calcul_V_moy0(tab_noeud,Phi,nomb_noeud); };
    return *V0;  
   };
// idem mais au noeud passé en paramètre  
const Coordonnee & Met_Sfe1::VitesseM_0(const Noeud* noeud)
  { if (noeud->Existe_ici(V1)) { Calcul_V0(noeud); }
    else                       { Calcul_V_moy0(noeud); };
    return *V0;  
   };
		  
// calcul de la vitesse du point M en fonction de phi et des coordonnees a t
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t 
const Coordonnee & Met_Sfe1::VitesseSfe1M_t // ( stockage a t=t)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
  { if (tab_noeud(1)->Existe_ici(V1))
      { Calcul_Vt(tab_noeud,Phi,nomb_noeud); }
    else 
      { Calcul_V_moyt(tab_noeud,Phi,nomb_noeud); };
    return *Vt;  
   };
// idem mais au noeud passé en paramètre  
const Coordonnee & Met_Sfe1::VitesseM_t(const Noeud* noeud)
  { if (noeud->Existe_ici(V1)) { Calcul_Vt(noeud); }
    else                       { Calcul_V_moyt(noeud); };
    return *Vt;  
   };

// calcul de la variation de la vitesse du point M par rapport aux ddl , 
// en fonction de phi et des coordonnees a t
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t 
// ddl_vitesse : indique si oui ou non il s'agit de variation par rapport 
//               aux ddl de vitesse ou au ddl de position 
const Tableau<Coordonnee> & Met_Sfe1::D_VitesseSfe1M_t // ( stockage a t)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi,bool ddl_vitesse)
  { if (tab_noeud(1)->Existe_ici(V1))
      { Calcul_d_Vt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = true;}
    else 
      { Calcul_d_V_moyt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = false;};
    return *d_Vt;  
   };
// idem mais au noeud passé en paramètre  
const Tableau<Coordonnee> & Met_Sfe1::D_VitesseSfe1M_t(const Noeud* noeud,bool ddl_vitesse)
  { if (noeud->Existe_ici(V1)) { Calcul_d_Vt(noeud); ddl_vitesse = true;}
    else                       { Calcul_d_V_moyt(noeud); ddl_vitesse = false; };
    return *d_Vt;  
   };
		  
// calcul de la vitesse du point M en fonction de phi et des coordonnees a tdt
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t 
const Coordonnee & Met_Sfe1::VitesseSfe1M_tdt // ( stockage a tdt)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
  { if (tab_noeud(1)->Existe_ici(V1))
      { Calcul_Vtdt(tab_noeud,Phi,nomb_noeud); }
    else 
      { Calcul_V_moytdt(tab_noeud,Phi,nomb_noeud);};
    return *Vtdt;  
   };
// idem mais au noeud passé en paramètre  
const Coordonnee & Met_Sfe1::VitesseSfe1M_tdt(const Noeud* noeud)
  { if (noeud->Existe_ici(V1)) { Calcul_Vtdt(noeud); }
    else                       { Calcul_V_moytdt(noeud); };
    return *Vtdt;  
   };

// calcul de la variation de la vitesse du point M par rapport aux ddl , 
// en fonction de phi et des coordonnees a tdt
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t 
// ddl_vitesse : indique si oui ou non il s'agit de variation par rapport 
//               aux ddl de vitesse ou au ddl de position 
const Tableau<Coordonnee> & Met_Sfe1::D_VitesseSfe1M_tdt // ( stockage a tdt)
		  (const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi,bool ddl_vitesse)
  { if (tab_noeud(1)->Existe_ici(V1))
      { Calcul_d_Vtdt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = true;}
    else 
      { Calcul_d_V_moytdt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = false; };
    return *d_Vtdt;  
   };
// idem mais au noeud passé en paramètre  
const Tableau<Coordonnee> & Met_Sfe1::D_VitesseSfe1M_tdt(const Noeud* noeud,bool ddl_vitesse)
  { if (noeud->Existe_ici(V1)) { Calcul_d_Vtdt(noeud); ddl_vitesse = true;}
    else                       { Calcul_d_V_moytdt(noeud); ddl_vitesse = false; };
    return *d_Vtdt;  
   };
		  
// calcul de la base naturel ( stockage a t=0) au point correspondant  au dphi
const BaseB& Met_Sfe1::BaseSfe1Nat_0   // en fonction des coordonnees a t=0
		  ( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
  { Calcul_giB_0 (tab_noeud,dphi,nomb_noeud,phi);
    return *giB_0;
   };
		  
// calcul de la base naturel ( stockage a t) au point correspondant  au dphi
const BaseB& Met_Sfe1::BaseSfe1Nat_t   // en fonction des coordonnees a t
		  ( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
  { Calcul_giB_t (tab_noeud,dphi,nomb_noeud,phi);
    return *giB_t;
   };
		  
// calcul de la base naturel ( stockage a t=tdt) au point correspondant  au dphi
const BaseB& Met_Sfe1::BaseSfe1Nat_tdt   // en fonction des coordonnees a tdt
		  ( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
  { Calcul_giB_tdt (tab_noeud,dphi,nomb_noeud,phi);
    return *giB_tdt;
   };
		  
// calcul de la base naturelle et duale ( stockage a t=0) en fonction des coord a 0 
void Met_Sfe1::BaseSfe1ND_0( const Tableau<Noeud *>& tab_noeud,const Mat_pleine& dphi,
                              const Vecteur& phi,BaseB& bB,BaseH& bH)
  { Calcul_giB_0 (tab_noeud,dphi,nomb_noeud,phi);
    Calcul_gijBB_0 ();  //      "
	Calcul_gijHH_0 ();        // composantes controvariantes
    Calcul_giH_0 ();
    bB = *giB_0;
    bH =  *giH_0;
   };
// calcul de la base naturelle et duale ( stockage a t) en fonction des coord a t 
void Met_Sfe1::BaseSfe1ND_t( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
                              const Vecteur& phi,BaseB& bB,BaseH& bH)
  { Calcul_giB_t (tab_noeud,dphi,nomb_noeud,phi);
    Calcul_gijBB_t ();  //      "
	Calcul_gijHH_t ();        // composantes controvariantes
    Calcul_giH_t ();
    bB = *giB_t;
    bH =  *giH_t;
   };
// calcul de la base naturelle et duale ( stockage a tdt) en fonction des coord a tdt 
void Met_Sfe1::BaseSfe1ND_tdt( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
                                const Vecteur& phi,BaseB& bB,BaseH& bH)
  { Calcul_giB_tdt (tab_noeud,dphi,nomb_noeud,phi);
    Calcul_gijBB_tdt ();  //      "
	Calcul_gijHH_tdt ();        // composantes controvariantes
    Calcul_giH_tdt ();
    bB = *giB_tdt;
    bH =  *giH_tdt;
   };

*/

