/*! \file Met_abstraite_stuc_donnees.h
    \brief def des structures de données de passage d'informations pour les métriques
*/

// 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/>.
 
 /************************************************************************
 *                                                                      *
 *     DATE:        15/01/97                                            *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 * deuxième partie du fichier Met_abstraite.h
 * contient en fait toutes les structures de données de passage d'informations
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                      *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                      *
 *                                                                $     *
 *                                                                      *
 ************************************************************************/


// deuxième partie du fichier Met_abstraite.h
// contient en fait toutes les structures de données de passage d'informations

	    // CLASSE CONTENEUR : cas explicite entre 0 et t, toutes les grandeurs sont a 0 ou t
	    // les données sont publiques
class Expli_t_tdt;
/// @}  // end of group

/// @addtogroup groupe_des_metrique
///  @{
///

class Expli
	     { public :
          Expli () :  // constructeur par défaut
	             giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),
              gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gradVBB_t(NULL),gradVmoyBB_t(NULL),d_gijBB_t(NULL),
		  	         jacobien_t(NULL),jacobien_0(NULL)
		  	       {};		  	        
          Expli  // constructeur normal
              (BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH *ggiH_t,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,
               TenseurHH * ggijHH_t,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVBB_t,
               Tableau <TenseurBB *>* gd_gijBB_t,double* gjacobien_t,double* gjacobien_0) : 
	              giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t)
               ,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t),gradVBB_t(ggradVBB_t)
               ,gradVmoyBB_t(ggradVmoyBB_t),d_gijBB_t(gd_gijBB_t)
		  	          ,jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
		  	       {}; 		  	        
          Expli (const Expli& ex) :  // constructeur de copie
	              giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),
               gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
               ,gradVBB_t(ex.gradVBB_t),gradVmoyBB_t(ex.gradVmoyBB_t),d_gijBB_t(ex.d_gijBB_t),
		  	          jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
		  	       {};
		  	     Expli& operator= (const Expli& ex)  // surcharge d'affectation
            {giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;
             gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
             gradVmoyBB_t=ex.gradVmoyBB_t;gradVBB_t=ex.gradVBB_t,d_gijBB_t=ex.d_gijBB_t;
		  	        jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
		  	        return *this;
            };
		  	     // une fonction qui permet de produire un objet Expli_t_tdt mais en mettant seulement les
		  	     // grandeur calculées à t commune à Expli_t_tdt
		  	     Expli_t_tdt T_dans_tdt() const 
		  	       {return Expli_t_tdt(giB_0,giH_0,giB_t,giH_t,NULL,NULL,gijBB_0,gijHH_0,gijBB_t,gijHH_t
                       ,NULL,NULL,gradVmoyBB_t,NULL,NULL,NULL,NULL,jacobien_t,jacobien_0);
            };
		  	     // mise à jour des grandeurs 
		  	     void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH *ggiH_t,
                       TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH * ggijHH_t,TenseurBB* ggradVmoyBB_t,
                       TenseurBB * ggradVBB_t,Tableau <TenseurBB *>* gd_gijBB_t,double* gjacobien_t,double* gjacobien_0)
            {giB_0=ggiB_0;giH_0=ggiH_0; giB_t=ggiB_t;giH_t=ggiH_t;
             gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;
             gradVmoyBB_t=ggradVmoyBB_t;gradVBB_t=ggradVBB_t,d_gijBB_t=gd_gijBB_t;
             jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
            };
		        // mise à jour des grandeurs à 0  sauf les variations (pas de tableau et pas à t)
		        // à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
		        // non de pointeur !)
		  	     void Recup_grandeur_0(BaseB & ggiB_0,BaseH & ggiH_0,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0
                                      ,double& gjacobien_0)		  	        	
            {*giB_0=ggiB_0;*giH_0=ggiH_0;*gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;
             *jacobien_0=gjacobien_0;
            };
	     
      // variables 
	       BaseB * giB_0; BaseH * giH_0; BaseB * giB_t; BaseH * giH_t;
        TenseurBB * gijBB_0; TenseurHH* gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t; 
        TenseurBB * gradVmoyBB_t;TenseurBB * gradVBB_t;Tableau <TenseurBB *>* d_gijBB_t;
        double *jacobien_t;double *jacobien_0;		  	        
		   };
/// @}  // end of group


  /// @addtogroup groupe_des_metrique
  ///  @{
  ///

  // --- CLASSE CONTENEUR : cas d'une procédure Umat
	    // les variables sont publiques
class Umat_cont
	 { public :
      Umat_cont () :  // constructeur par défaut
	         giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),giH_tdt(NULL)
          ,gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
          ,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL)
          ,jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL)
		  	          {};		  	        
      Umat_cont  // constructeur normal
          (BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t, BaseH * ggiH_t,BaseB * ggiB_tdt,BaseH *ggiH_tdt
          ,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
          ,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
          ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
          ,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0
          ) :
	           giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),giH_tdt(ggiH_tdt)
	           ,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t)
	           ,gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
	           ,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt)
	           ,jacobien_tdt(gjacobien_tdt),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
		  	           {}; 		  	        
      Umat_cont (const Umat_cont& ex) :  // constructeur de copie
	           giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),giH_tdt(ex.giH_tdt)
	           ,gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
	           ,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
	           ,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt)
	           ,jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
		  	           {};
		  	 Umat_cont& operator= (const Umat_cont& ex)  // surcharge d'affectation	  	        
	               { giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;giH_tdt=ex.giH_tdt;
	                 gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
	                 gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
                  gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
                  jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
		  	             return *this;
                 };
		  	           
		  	 // mise à jour des grandeurs 
		  	 void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t
		  	       ,BaseB * ggiB_tdt,BaseH *ggiH_tdt
		  	       ,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0, TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
		  	       ,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
		  	       ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
            ,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0)
                { giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;giH_tdt=ggiH_tdt;
	                 gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
	                 gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
	                 jacobien_tdt=gjacobien_tdt;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
		  	           };
	      // méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre2_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre2(const Umat_cont& ex,int type_recopie);
    
	      // méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre1_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre1(const Umat_cont& ex,int type_recopie);
    
	      // méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre1_vers_Ordre2(const Umat_cont& ex,bool plusZero,int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre2, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre2
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre2_vers_Ordre1(const Umat_cont& ex,int type_recopie);
   
  // ------ variables --------
	     BaseB * giB_0; BaseH * giH_0; BaseB * giB_t;BaseH * giH_t;BaseB * giB_tdt;BaseH * giH_tdt;
      TenseurBB * gijBB_0; TenseurHH * gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t;
      TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt;
      TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt;
      double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
		 }; 	        
/// @}  // end of group

// --- fin CLASSE CONTENEUR : cas d'une procédure Umat


/// @addtogroup groupe_des_metrique
///  @{
///

// CLASSE CONTENEUR : cas explicite entre 0 et tdt, les grandeurs sont a 0 ou t et tdt
// les variables sont publiques
class Expli_t_tdt
 { public :
     Expli_t_tdt () :  // constructeur par défaut
         giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),giH_tdt(NULL)
         ,gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
         ,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL),d_gijBB_tdt(NULL)
         ,jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL)
           {};		  	        
     Expli_t_tdt  // constructeur normal
       (BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH *ggiH_t,BaseB * ggiB_tdt,BaseH *ggiH_tdt
        ,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
        ,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
        ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
        ,Tableau <TenseurBB *>* gd_gijBB_tdt,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0) :
        giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),giH_tdt(ggiH_tdt)
        ,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t)
        ,gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
        ,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt)
        ,d_gijBB_tdt(gd_gijBB_tdt)
        ,jacobien_tdt(gjacobien_tdt),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
           {}; 		  	        
     Expli_t_tdt (const Expli_t_tdt& ex) :  // constructeur de copie
        giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),giH_tdt(ex.giH_tdt)
        ,gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
        ,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
        ,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt)
        ,d_gijBB_tdt(ex.d_gijBB_tdt)
        ,jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
           {};
     Expli_t_tdt& operator= (const Expli_t_tdt& ex)  // surcharge d'affectation
         {giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;giH_tdt=ex.giH_tdt;
          gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
          gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
          gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
          d_gijBB_tdt=ex.d_gijBB_tdt;
          jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
          return *this;};
           
		  	// une fonction qui permet de produire un objet expli mais en mettant les grandeurs
		  	// à tdt de l'objet expli_t_tdt à la place des grandeurs à t de l'objet expli
		  	Expli Tdt_dans_t() const 
		  	  { return Expli(giB_0,giH_0,giB_tdt,giH_tdt,gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,gradVmoyBB_tdt
                      ,gradVBB_tdt,d_gijBB_tdt,jacobien_tdt,jacobien_0);
       };
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t
		  	  ,BaseB * ggiB_tdt,BaseH *ggiH_tdt
		  	  ,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
		  	  ,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
		  	  ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
       ,Tableau <TenseurBB *>* gd_gijBB_tdt,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0)
	         {giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;giH_tdt=ggiH_tdt;
	          gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
	          gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
	          d_gijBB_tdt=gd_gijBB_tdt;
           jacobien_tdt=gjacobien_tdt;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
          };
		    // mise à jour des grandeurs à 0 et à t sauf les variations (pas de tableau et pas à tdt)
		    // à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
		    // non de pointeur !)
		  	 void Recup_grandeur_0_t(BaseB & ggiB_0,BaseH & ggiH_0,BaseB & ggiB_t,BaseH& ggiH_t
                 ,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0,TenseurBB& ggijBB_t,TenseurHH& ggijHH_t
                 ,TenseurBB & ,double& gjacobien_t,double& gjacobien_0)
	            {*giB_0=ggiB_0;*giH_0=ggiH_0;*giB_t=ggiB_t;*giH_t=ggiH_t;
                 *gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;*gijBB_t=ggijBB_t;*gijHH_t=ggijHH_t;
                 *jacobien_t=gjacobien_t;*jacobien_0=gjacobien_0;//*gradVmoyBB_t=ggradVmoyBB_t;
	            };
	      // méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre2_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero, int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre2(const Expli_t_tdt& ex, int type_recopie);
	     
	     // méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	     // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	     // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	     // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	     //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre1_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero, int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre1(const Expli_t_tdt& ex, int type_recopie);
    
       // récupération d'une instance Umat_cont, contenant les grandeurs associés à this
       Umat_cont & Recup_Umat_cont(Umat_cont& ex)const
        { ex.giB_0 = giB_0;ex.giH_0= giH_0;ex.giB_t=giB_t;ex.giH_t=giH_t;ex.giB_tdt=giB_tdt;ex.giH_tdt=giH_tdt;
          ex.gijBB_0=gijBB_0; ex.gijHH_0=gijHH_0; ex.gijBB_t=gijBB_t;ex.gijHH_t=gijHH_t;
          ex.gijBB_tdt=gijBB_tdt;ex.gijHH_tdt=gijHH_tdt;
          ex.gradVmoyBB_t=gradVmoyBB_t;ex.gradVmoyBB_tdt=gradVmoyBB_tdt;ex.gradVBB_tdt=gradVBB_tdt;
          ex.jacobien_tdt=jacobien_tdt;ex.jacobien_t=jacobien_t;ex.jacobien_0=jacobien_0;
          return ex;
        };
  
	// ------ variables
     BaseB * giB_0; BaseH * giH_0; BaseB * giB_t;BaseH* giH_t;BaseB * giB_tdt;BaseH * giH_tdt;
     TenseurBB * gijBB_0; TenseurHH* gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t;
     TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt;
     TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt;
     Tableau <TenseurBB *>* d_gijBB_tdt;
     double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
		 }; 	        
/// @}  // end of group



/// @addtogroup groupe_des_metrique
///  @{
///

// CLASSE CONTENEUR : cas implicite ----------------------------------------------------------------
		// calcul des termes de la classe impli
class Impli
		 { public :
       Impli () : // constructeur par défaut
	         giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),d_giB_tdt(NULL),giH_tdt(NULL)
	         ,d_giH_tdt(NULL),gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
          ,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL),d_gijBB_tdt(NULL),d2_gijBB_tdt(NULL)
		  	     ,d_gijHH_tdt(NULL), jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL),d_jacobien_tdt(NULL)
		  	     ,d_gradVmoyBB_t(NULL),d_gradVmoyBB_tdt(NULL),d_gradVBB_t(NULL),d_gradVBB_tdt(NULL)
		  	      {};		  	        
       Impli  // constructeur normal 
          (BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t, BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
           ,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
           ,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t
           ,TenseurHH* ggijHH_t,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
           ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
           ,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
           ,Tableau <TenseurHH *>* gd_gijHH_tdt
           ,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
           ,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
		  	      ,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
          ) :
	             giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),d_giB_tdt(d_ggiB_tdt),
	             giH_tdt(ggiH_tdt),d_giH_tdt(d_ggiH_tdt),
              gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
              ,gijBB_t(ggijBB_t),gijHH_t(ggijHH_t),gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
              ,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt),
              d_gijBB_tdt(gd_gijBB_tdt),d2_gijBB_tdt(gd2_gijBB_tdt),d_gijHH_tdt(gd_gijHH_tdt),
              jacobien_tdt(gjacobien),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0),d_jacobien_tdt(gd_jacobien_tdt)
		  	         ,d_gradVmoyBB_t(gd_gradVmoyBB_t),d_gradVmoyBB_tdt(gd_gradVmoyBB_tdt)
		  	         ,d_gradVBB_t(gd_gradVBB_t),d_gradVBB_tdt(gd_gradVBB_tdt)
		  	          {};		  	        
       Impli (const Impli& ex) : // constructeur de copie
	             giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),d_giB_tdt(ex.d_giB_tdt)
	             ,giH_tdt(ex.giH_tdt),d_giH_tdt(ex.d_giH_tdt),
              gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
              ,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
              ,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt),
              d_gijBB_tdt(ex.d_gijBB_tdt),d2_gijBB_tdt(ex.d2_gijBB_tdt),d_gijHH_tdt(ex.d_gijHH_tdt),
              jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0),d_jacobien_tdt(ex.d_jacobien_tdt)
		  	         ,d_gradVmoyBB_t(ex.d_gradVmoyBB_t),d_gradVmoyBB_tdt(ex.d_gradVmoyBB_tdt)
		  	         ,d_gradVBB_t(ex.d_gradVBB_t),d_gradVBB_tdt(ex.d_gradVBB_tdt)
		  	          {};		  	        

       Impli& operator= (const Impli& ex)  // surcharge d'affectation
	              {giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;d_giB_tdt=ex.d_giB_tdt;
	               giH_tdt=ex.giH_tdt;d_giH_tdt=ex.d_giH_tdt;
                gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0; gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
                gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
                gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
                d_gijBB_tdt=ex.d_gijBB_tdt;d2_gijBB_tdt=ex.d2_gijBB_tdt;d_gijHH_tdt=ex.d_gijHH_tdt;
		  	           jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
                d_jacobien_tdt=ex.d_jacobien_tdt;
		  	           d_gradVmoyBB_t=ex.d_gradVmoyBB_t;d_gradVmoyBB_tdt=ex.d_gradVmoyBB_tdt;
		  	           d_gradVBB_t=ex.d_gradVBB_t;d_gradVBB_tdt=ex.d_gradVBB_tdt;
		  	           return *this;
               };
		  	  // mise à jour des grandeurs 
       void Mise_a_jour_grandeur
                       (BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH* ggiH_t
		  	                   ,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
                        ,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
                        ,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t
                        ,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
                        ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
                        ,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
                        ,Tableau <TenseurHH *>* gd_gijHH_tdt
                        ,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
                        ,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
		  	                   ,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
                       )
	                   {giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;d_giB_tdt=d_ggiB_tdt;
	                    giH_tdt=ggiH_tdt;d_giH_tdt=d_ggiH_tdt;
                     gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;
                     gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
                     gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
                     d_gijBB_tdt=gd_gijBB_tdt;d2_gijBB_tdt=gd2_gijBB_tdt;d_gijHH_tdt=gd_gijHH_tdt;
		  	                jacobien_tdt=gjacobien;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
                     d_jacobien_tdt=gd_jacobien_tdt;
		  	                d_gradVmoyBB_t=gd_gradVmoyBB_t;d_gradVmoyBB_tdt=gd_gradVmoyBB_tdt;
		  	                d_gradVBB_t=gd_gradVBB_t;d_gradVBB_tdt=gd_gradVBB_tdt;
                    };
		    // mise à jour des grandeurs à 0 et à t sauf les variations (pas de tableau et pas à tdt)
		    // à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
		    // non de pointeur !)
		  	 void Recup_grandeur_0_t(BaseB & ggiB_0,BaseH & ggiH_0,BaseB & ggiB_t,BaseH& ggiH_t
                              ,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0,TenseurBB& ggijBB_t,TenseurHH& ggijHH_t
                              ,TenseurBB & ,double& gjacobien_t,double& gjacobien_0
                             )
	                   { *giB_0=ggiB_0;*giH_0=ggiH_0;*giB_t=ggiB_t;*giH_t=ggiH_t;
                      *gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;*gijBB_t=ggijBB_t;*gijHH_t=ggijHH_t;
                      *jacobien_t=gjacobien_t;*jacobien_0=gjacobien_0;//*gradVmoyBB_t=ggradVmoyBB_t;
	                   };
	      // méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre2_vers_Ordre3(const Impli& ex,bool plusZero, int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre2(const Impli& ex, int type_recopie);
    
	      // méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre1_vers_Ordre3(const Impli& ex,bool plusZero, int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre3_vers_Ordre1(const Impli& ex, int type_recopie);
    
	      // méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
	      // il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
	      // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
	      // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
	      //        on se réfère donc aux grandeurs de  l'argument : ex
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre1_vers_Ordre2(const Impli& ex,bool plusZero, int type_recopie);
					  // méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
					  // il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre2, comme la cible est plus petite que l'origine
					  //                             on n'a pas besoin de complèter avec des 0
					  // --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
					  // --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
					  //                       c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre2
					  //                       pour laquelle c'était les éléments de ex qui servaient de modèle  
       // type recopie :   = 0 -> on transfert les grandeurs à 0, t et tdt
       //                  = 1 -> on transfert les grandeurs à t et tdt
       //                  = 2 -> on transfert les grandeurs à tdt
					  void Passage_de_Ordre2_vers_Ordre1(const Impli& ex, int type_recopie);
    
       // récupération d'une instance Umat_cont, contenant les grandeurs associés à this
       Umat_cont & Recup_Umat_cont(Umat_cont& ex)const
        { ex.giB_0 = giB_0;ex.giH_0= giH_0;ex.giB_t=giB_t;ex.giH_t=giH_t;ex.giB_tdt=giB_tdt;ex.giH_tdt=giH_tdt;
          ex.gijBB_0=gijBB_0; ex.gijHH_0=gijHH_0; ex.gijBB_t=gijBB_t;ex.gijHH_t=gijHH_t;
          ex.gijBB_tdt=gijBB_tdt;ex.gijHH_tdt=gijHH_tdt;
          ex.gradVmoyBB_t=gradVmoyBB_t;ex.gradVmoyBB_tdt=gradVmoyBB_tdt;ex.gradVBB_tdt=gradVBB_tdt;
          ex.jacobien_tdt=jacobien_tdt;ex.jacobien_t=jacobien_t;ex.jacobien_0=jacobien_0;
          return ex;
        };
    
		 // ---------- variables -------- :
   
		    BaseB * giB_0; BaseH * giH_0; BaseB * giB_t; BaseH * giH_t;BaseB * giB_tdt;Tableau <BaseB> * d_giB_tdt;
		    BaseH * giH_tdt;Tableau <BaseH> * d_giH_tdt;
      TenseurBB * gijBB_0; TenseurHH * gijHH_0; 
      TenseurBB * gijBB_t ; TenseurHH * gijHH_t ;TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt; 
      TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt; Tableau <TenseurBB *> * d_gijBB_tdt;
		  	 Tableau2 <TenseurBB *> * d2_gijBB_tdt; 
		  	 Tableau <TenseurHH *>* d_gijHH_tdt;
      double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
		  	 Vecteur* d_jacobien_tdt;
		  	 Tableau <TenseurBB * >* d_gradVmoyBB_t;Tableau <TenseurBB * >* d_gradVmoyBB_tdt;
		  	 Tableau <TenseurBB * >* d_gradVBB_t;Tableau <TenseurBB * >* d_gradVBB_tdt;
		 };
/// @}  // end of group



/// @addtogroup groupe_des_metrique
///  @{
///

// classe pour le calcul de gijHH_0 et de giH_0 juste après le calcul implicite
// (sinon il y a erreur)
class gijHH_0_et_giH_0  
  { public: 
		    gijHH_0_et_giH_0 () : giH_0(NULL),gijHH_0(NULL)  {}; // constructeur par défaut
      gijHH_0_et_giH_0 // constructeur normal
              (BaseH * ggiH_0,TenseurHH * ggijHH_0) : giH_0(ggiH_0),gijHH_0(ggijHH_0) {};  
      gijHH_0_et_giH_0 (const gijHH_0_et_giH_0& ex) : // constructeur de copie
	          giH_0(ex.giH_0),gijHH_0(ex.gijHH_0) {};		  	        
      gijHH_0_et_giH_0& operator= (const gijHH_0_et_giH_0& ex)  // surcharge d'affectation
	          {giH_0=ex.giH_0;gijHH_0=ex.gijHH_0;return *this;};
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(BaseH * ggiH_0,TenseurHH * ggijHH_0)
	          {giH_0=ggiH_0;gijHH_0=ggijHH_0;};
  // ------ variables --------
     TenseurHH * gijHH_0; BaseH * giH_0;
  };
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

// CLASSE CONTENEUR : cas de la dynamique
// calcul des termes de la classe Dynamiq 	
class Dynamiq
  { public :
      Dynamiq () : // constructeur par défaut
	        giB_0(NULL),giB_tdt(NULL),gijBB_0(NULL),gijBB_tdt(NULL)
         ,jacobien_tdt(NULL),jacobien_0(NULL)
             {};		  	        
      Dynamiq  // constructeur normal 
              (BaseB * ggiB_0,BaseB * ggiB_tdt,TenseurBB * ggijBB_0,TenseurBB * ggijBB_tdt
               ,double* gjacobien_tdt,double* gjacobien_0
              ) :
	        giB_0(ggiB_0),giB_tdt(ggiB_tdt),gijBB_0(ggijBB_0),gijBB_tdt(ggijBB_tdt)
         ,jacobien_tdt(gjacobien_tdt),jacobien_0(gjacobien_0)
             {};		  	        
      Dynamiq (const Dynamiq& ex) : // constructeur de copie
	        giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),gijBB_0(ex.gijBB_0),gijBB_tdt(ex.gijBB_tdt)
		  	    ,jacobien_tdt(ex.jacobien_tdt),jacobien_0(ex.jacobien_0)
             {};		  	        

      Dynamiq& operator= (const Dynamiq& ex)  // surcharge d'affectation
	            { giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;gijBB_0=ex.gijBB_0;gijBB_tdt=ex.gijBB_tdt;
		  	          jacobien_tdt=ex.jacobien_tdt;jacobien_0=ex.jacobien_0;
		  	          return *this;
             };
      // mise à jour des grandeurs 
		  	 void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseB * ggiB_tdt,TenseurBB * ggijBB_0,TenseurBB * ggijBB_tdt
                                ,double* gjacobien_tdt,double* gjacobien_0)
	            { giB_0=ggiB_0;giB_tdt=ggiB_tdt;gijBB_0=ggijBB_0;gijBB_tdt=ggijBB_tdt;
               jacobien_tdt=gjacobien_tdt;jacobien_0=gjacobien_0;
             };		  	        
		 
  // ------ variables --------
		    BaseB * giB_0;  BaseB * giB_tdt;
      TenseurBB * gijBB_0; TenseurBB * gijBB_tdt;
		  	 double* jacobien_tdt;double* jacobien_0;
		 };
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

class flambe_lin : public Impli
		 { public :
		    flambe_lin(): // constructeur par défaut
		       Impli()
            {};
		    flambe_lin // constructeur avec tous les paramètres
            (BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH * ggiH_t,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
             ,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
             ,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t
             ,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
             ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
             ,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
             ,Tableau <TenseurHH *>* gd_gijHH_tdt
             ,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
             ,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
             ,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
            ):
		  	        Impli(ggiB_0,ggiH_0,ggiB_t,ggiH_t,ggiB_tdt,d_ggiB_tdt,ggiH_tdt,d_ggiH_tdt
                   ,ggijBB_0,ggijHH_0,ggijBB_t,ggijHH_t,ggijBB_tdt,ggijHH_tdt,ggradVmoyBB_t,ggradVmoyBB_tdt,ggradVBB_tdt
                   ,gd_gijBB_tdt,gd2_gijBB_tdt,gd_gijHH_tdt,gjacobien,gjacobien_t,gjacobien_0,gd_jacobien_tdt
                   ,gd_gradVmoyBB_t,gd_gradVmoyBB_tdt
		  	              ,gd_gradVBB_t,gd_gradVBB_tdt
                  )
              {};
    
		    flambe_lin(const flambe_lin & ex) : // constructeur de copie
		          Impli(ex)
              {};
      flambe_lin& operator= (const flambe_lin& ex)  // surcharge d'affectation
		  	         { this->Impli::operator= ((Impli&) ex);
		  	           return *this;
              };
		  	 // mise à jour des grandeurs 
		  	 void Mise_a_jour_grandeur
                       (BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH* ggiH_t
		  	                   ,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
                        ,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
                        ,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
                        ,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
                        ,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
                        ,Tableau <TenseurHH *>* gd_gijHH_tdt
                        ,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
                        ,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
		  	                   ,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
                       )
		  	        { Impli::Mise_a_jour_grandeur(ggiB_0,ggiH_0,ggiB_t,ggiH_t,ggiB_tdt,d_ggiB_tdt,ggiH_tdt,d_ggiH_tdt
                        ,ggijBB_0,ggijHH_0,ggijBB_t,ggijHH_t,ggijBB_tdt,ggijHH_tdt,ggradVmoyBB_t,ggradVmoyBB_tdt,ggradVBB_tdt
                        ,gd_gijBB_tdt,gd2_gijBB_tdt,gd_gijHH_tdt,gjacobien,gjacobien_t,gjacobien_0,gd_jacobien_tdt
                        ,gd_gradVmoyBB_t,gd_gradVmoyBB_tdt
		  	                   ,gd_gradVBB_t,gd_gradVBB_tdt);
             };

    // ------- variables (idem Impli)
		 }; 	
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

class InfoImp
  {public : 
		   InfoImp(): // constructeur par défaut
		     M0(NULL),Mtdt(NULL),giB_0(NULL),giB_tdt(NULL),giH_0(NULL),giH_tdt(NULL),gijHH_tdt(NULL),gijBB_tdt(NULL)
		     ,gijBB_0(NULL),gijHH_0(NULL)
		       {};
		   InfoImp // constructeur avec toutes les variables
		          (Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0):
		     M0(gM0),Mtdt(gMtdt),giB_0(ggiB_0),giB_tdt(ggiB_tdt),giH_0(ggiH_0),giH_tdt(ggiH_tdt)
		     ,gijHH_tdt(ggijHH_tdt),gijBB_tdt(ggijBB_tdt),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
		       {};
		   InfoImp (const InfoImp & ex): // constructeur de copie		          
		     M0(ex.M0),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),giH_0(ex.giH_0),giH_tdt(ex.giH_tdt)
		     ,gijHH_tdt(ex.gijHH_tdt),gijBB_tdt(ex.gijBB_tdt),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
		       {};
     InfoImp& operator= (const InfoImp& ex)  // surcharge d'affectation
             { M0=ex.M0;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;giH_0=ex.giH_0;giH_tdt=ex.giH_tdt;
		             gijHH_tdt=ex.gijHH_tdt;gijBB_tdt=ex.gijBB_tdt;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
               return *this;
             };
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
             { M0=gM0;Mtdt=gMtdt;giB_0=ggiB_0;giB_tdt=ggiB_tdt;giH_0=ggiH_0;giH_tdt=ggiH_tdt;
		             gijHH_tdt=ggijHH_tdt;gijBB_tdt=ggijBB_tdt;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
             };		   

  // ------ variables --------
		   Coordonnee *M0; Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_tdt;
		   BaseH * giH_0; BaseH * giH_tdt;TenseurHH * gijHH_tdt;TenseurBB * gijBB_tdt;
		   TenseurBB * gijBB_0;TenseurHH * gijHH_0;
		 }; 	
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

class InfoExp_t
	     { public : 
		   InfoExp_t(): // constructeur par défaut
		     M0(NULL),Mt(NULL),giB_0(NULL),giB_t(NULL),giH_0(NULL),giH_t(NULL),gijHH_t(NULL),gijBB_t(NULL)
		     ,gijBB_0(NULL),gijHH_0(NULL)
		       {};
		   InfoExp_t // constructeur avec toutes les variables
		          (Coordonnee *gM0,Coordonnee *gMt,BaseB * ggiB_0,BaseB * ggiB_t,
		           BaseH * ggiH_0, BaseH * ggiH_t,TenseurHH * ggijHH_t,TenseurBB * ggijBB_t
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0):
		     M0(gM0),Mt(gMt),giB_0(ggiB_0),giB_t(ggiB_t),giH_0(ggiH_0),giH_t(ggiH_t)
		     ,gijHH_t(ggijHH_t),gijBB_t(ggijBB_t),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
		       {};
		   InfoExp_t (const InfoExp_t & ex): // constructeur de copie		          
		     M0(ex.M0),Mt(ex.Mt),giB_0(ex.giB_0),giB_t(ex.giB_t),giH_0(ex.giH_0),giH_t(ex.giH_t)
		     ,gijHH_t(ex.gijHH_t),gijBB_t(ex.gijBB_t),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
		       {};
     InfoExp_t& operator= (const InfoExp_t& ex)  // surcharge d'affectation
             { M0=ex.M0;Mt=ex.Mt;giB_0=ex.giB_0;giB_t=ex.giB_t;giH_0=ex.giH_0;giH_t=ex.giH_t;
		             gijHH_t=ex.gijHH_t;gijBB_t=ex.gijBB_t;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
               return *this;
             };
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMt,BaseB * ggiB_0,BaseB * ggiB_t,
		           BaseH * ggiH_0, BaseH * ggiH_t,TenseurHH * ggijHH_t,TenseurBB * ggijBB_t
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
             { M0=gM0;Mt=gMt;giB_0=ggiB_0;giB_t=ggiB_t;giH_0=ggiH_0;giH_t=ggiH_t;
		             gijHH_t=ggijHH_t;gijBB_t=ggijBB_t;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
             };		   

  // ------ variables --------
     Coordonnee *M0; Coordonnee *Mt;BaseB * giB_0; BaseB * giB_t;
		   BaseH * giH_0; BaseH * giH_t;TenseurHH * gijHH_t;TenseurBB * gijBB_t;		  	        
		   TenseurBB * gijBB_0;TenseurHH * gijHH_0;
		 }; 	        
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

class InfoExp_tdt
  { public : 
		   InfoExp_tdt(): // constructeur par défaut
		     M0(NULL),Mtdt(NULL),giB_0(NULL),giB_tdt(NULL),giH_0(NULL),giH_tdt(NULL),gijHH_tdt(NULL),gijBB_tdt(NULL)
		     ,gijBB_0(NULL),gijHH_0(NULL)
		       {};
		   InfoExp_tdt // constructeur avec toutes les variables
		          (Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0
            ):
		     M0(gM0),Mtdt(gMtdt),giB_0(ggiB_0),giB_tdt(ggiB_tdt),giH_0(ggiH_0),giH_tdt(ggiH_tdt)
		     ,gijHH_tdt(ggijHH_tdt),gijBB_tdt(ggijBB_tdt),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
		       {};
		   InfoExp_tdt (const InfoExp_tdt & ex): // constructeur de copie		          
		     M0(ex.M0),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),giH_0(ex.giH_0),giH_tdt(ex.giH_tdt)
		     ,gijHH_tdt(ex.gijHH_tdt),gijBB_tdt(ex.gijBB_tdt),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
		       {};
     InfoExp_tdt& operator= (const InfoExp_tdt& ex)  // surcharge d'affectation
             { M0=ex.M0;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;giH_0=ex.giH_0;giH_tdt=ex.giH_tdt;
		             gijHH_tdt=ex.gijHH_tdt;gijBB_tdt=ex.gijBB_tdt;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
               return *this;
             };
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
		           ,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
             { M0=gM0;Mtdt=gMtdt;giB_0=ggiB_0;giB_tdt=ggiB_tdt;giH_0=ggiH_0;giH_tdt=ggiH_tdt;
		             gijHH_tdt=ggijHH_tdt;gijBB_tdt=ggijBB_tdt;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
             };		   
	     
  // ------ variables --------
     Coordonnee *M0; Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_tdt;
		   BaseH * giH_0; BaseH * giH_tdt;TenseurHH * gijHH_tdt;TenseurBB * gijBB_tdt;		  	        
		   TenseurBB * gijBB_0;TenseurHH * gijHH_0;
  }; 	        
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

class Info0_t_tdt
  { public : 
		   Info0_t_tdt(): // constructeur par défaut
		     M0(NULL),Mt(NULL),Mtdt(NULL),giB_0(NULL),giB_t(NULL),giB_tdt(NULL)
		     ,giH_0(NULL),giH_t(NULL),giH_tdt(NULL)
		       {};
		   Info0_t_tdt // constructeur avec toutes les variables
		          (Coordonnee *gM0,Coordonnee *gMt,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_t,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_t,BaseH * ggiH_tdt):
		     M0(gM0),Mt(gMt),Mtdt(gMtdt),giB_0(ggiB_0),giB_t(ggiB_t),giB_tdt(ggiB_tdt)
		     ,giH_0(ggiH_0),giH_t(ggiH_t),giH_tdt(ggiH_tdt)
		       {};
		   Info0_t_tdt (const Info0_t_tdt & ex): // constructeur de copie		          
		     M0(ex.M0),Mt(ex.Mt),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_t(ex.giB_t),giB_tdt(ex.giB_tdt)
		     ,giH_0(ex.giH_0),giH_t(ex.giH_t),giH_tdt(ex.giH_tdt)
		       {};
     Info0_t_tdt& operator= (const Info0_t_tdt& ex)  // surcharge d'affectation
             { M0=ex.M0;Mt=ex.Mt;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_t=ex.giB_t;giB_tdt=ex.giB_tdt;
               giH_0=ex.giH_0;giH_t=ex.giH_t;giH_tdt=ex.giH_tdt;
               return *this;
             };
		  	// mise à jour des grandeurs 
		  	void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMt,Coordonnee *gMtdt
		  	       ,BaseB * ggiB_0,BaseB * ggiB_t,BaseB * ggiB_tdt,
		           BaseH * ggiH_0, BaseH * ggiH_t,BaseH * ggiH_tdt)
             { M0=gM0;Mt=gMt;Mtdt=gMtdt;giB_0=ggiB_0;giB_t=ggiB_t;giB_tdt=ggiB_tdt;
               giH_0=ggiH_0;giH_t=ggiH_t;giH_tdt=ggiH_tdt;
             };		   
	     
  // ------ variables --------
    Coordonnee *M0; Coordonnee *Mt;Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_t;BaseB * giB_tdt;
    BaseH * giH_0; BaseH * giH_t;BaseH * giH_tdt;
  };
/// @}  // end of group


/// @addtogroup groupe_des_metrique
///  @{
///

// CLASSE CONTENEUR : pour le transfert d'information grandeurs à t = 0, t et tdt et
//                    toutes les métriques associées
// la classe Umat_cont, contient les mêmes informations qui sont utiles
// dans l'utilisation d'information déjà calculées
typedef Umat_cont Info_et_metrique_0_t_tdt;

/// @}  // end of group





