
// 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 "Debug.h"
# include "Met_abstraite.h"   
# include "Util.h"
#include "Tenseur3.h"
#include "Tenseur1.h"
using namespace std;  //introduces namespace std

// 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 Met_abstraite::Expli_t_tdt::Passage_de_Ordre2_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
 { // cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  // cas des tableaux : vérif
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  == NULL)&&(ex.d_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur null et ex.d_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };
	};  		  
   #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this
 
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL)
           {((Tenseur3BB*) gradVmoyBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_t),plusZero);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVBB_tdt),plusZero);};
        
        if(ex.d_gijBB_tdt != NULL)
          { int taille = ex.d_gijBB_tdt->Taille();
            for (int i=1;i<= taille ; i++)
              {((Tenseur3BB*) (*d_gijBB_tdt)(i))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gijBB_tdt)(i)),plusZero);};
      //    (*d_gijBB_tdt)(i) = (*ex.d_gijBB_tdt)(i);
         };
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};

// 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 Met_abstraite::Expli_t_tdt::Passage_de_Ordre3_vers_Ordre2(const Expli_t_tdt& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  // cas des tableaux : vérif
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  != NULL)&&(ex.d_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur non nul et ex.d_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur2BB*) gijBB_0)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_0));};
        if (gijHH_0 != NULL) {((Tenseur2HH*) gijHH_0)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_0));};
        (*jacobien_0) = (*ex.jacobien_0);
       }
    case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur2BB*) gijBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_t));};
        if (gijHH_t != NULL) {((Tenseur2HH*) gijHH_t)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_t));};
        if (gradVmoyBB_t != NULL) {((Tenseur2BB*) gradVmoyBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_t));};
       }

     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (gijBB_tdt != NULL) {((Tenseur2BB*) gijBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_tdt));};
        if (gijHH_tdt != NULL) {((Tenseur2HH*) gijHH_tdt)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_tdt));};
        if (gradVmoyBB_tdt != NULL) {((Tenseur2BB*) gradVmoyBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_tdt));};
        if (gradVBB_tdt != NULL) {((Tenseur2BB*) gradVBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVBB_tdt));};
        if(d_gijBB_tdt != NULL)
          { int taille = d_gijBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          {((Tenseur2BB*) (*d_gijBB_tdt)(i))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gijBB_tdt)(i)));};
      //    (*d_gijBB_tdt)(i) = (*ex.d_gijBB_tdt)(i);
         };
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 

};
      
// 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 Met_abstraite::Impli::Passage_de_Ordre2_vers_Ordre3(const Impli& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  // cas des tableaux : vérif
  //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  == NULL)&&(ex.d_giB_tdt != NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur null et ex.d_giB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_giB_tdt != NULL)
	 { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
	     {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
		        << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_giH_tdt  == NULL)&&(ex.d_giH_tdt != NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur null et ex.d_giH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_giH_tdt != NULL)
	 { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
	     {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
		        << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
    
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  == NULL)&&(ex.d_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur null et ex.d_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d2_gijBB_tdt  == NULL)&&(ex.d2_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur null et ex.d2_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d2_gijBB_tdt != NULL)
	 { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
	       || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
	     {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
		         << " et " << d2_gijBB_tdt->Taille2()
		        << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
				  << " et " << ex.d2_gijBB_tdt->Taille2()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
	  
   if((d_gijHH_tdt  == NULL)&&(ex.d_gijHH_tdt != NULL))	
     {cout << "\n *** erreur d_gijHH_tdt est un pointeur null et ex.d_gijHH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijHH_tdt != NULL)
	 { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
	     {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
		        << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_t  == NULL)&&(ex.d_gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur null et ex.d_gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVmoyBB_t != NULL)
	 { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_tdt  == NULL)&&(ex.d_gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur null et ex.d_gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVmoyBB_tdt != NULL)
	 { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_t  == NULL)&&(ex.d_gradVBB_t != NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur null et ex.d_gradVBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVBB_t != NULL)
	 { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
	     {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
		        << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_tdt  == NULL)&&(ex.d_gradVBB_tdt != NULL))	
     {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVBB_tdt != NULL)
	 { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  

  //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  == NULL)&&(ex.d_jacobien_tdt != NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur null et ex.d_jacobien_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_jacobien_tdt != NULL)
	 { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
	     {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
		        << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
	           << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	  };		  
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur3BB*) gradVmoyBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_t),plusZero);};
        if(ex.d_gradVmoyBB_t != NULL)
          { int taille = ex.d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur3BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gradVmoyBB_t)(i)),plusZero);
         };
        if(ex.d_gradVBB_t != NULL)
          { int taille = ex.d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur3BB*) ((*d_gradVBB_t)(i)))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gradVBB_t)(i)),plusZero);
         };
       }
    case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
         if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
         if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
         if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_tdt),plusZero);};
         if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_tdt),plusZero);};
         if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_tdt),plusZero);};
         if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVBB_tdt),plusZero);};
         // on considère que c'est toujours ok pour les pointeurs de jacobiens
         (*jacobien_tdt) = (*ex.jacobien_tdt);
         // cas des tableaux
         //   -- les tableaux de pointeurs de base
         if(ex.d_giB_tdt != NULL)
         { int taille = ex.d_giB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
          };
         if(ex.d_giH_tdt != NULL)
         { int taille = ex.d_giH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
          };
        
         //    -- les tableaux de pointeurs de tenseurs
         if(ex.d_gijBB_tdt != NULL)
           { int taille = ex.d_gijBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gijBB_tdt)(i)))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gijBB_tdt)(i)),plusZero);
          };
         if(ex.d2_gijBB_tdt != NULL)
           { int taille1 = ex.d2_gijBB_tdt->Taille1();
           int taille2 = ex.d2_gijBB_tdt->Taille2();
           for (int i=1;i<= taille1 ; i++)
             for (int j=1;j<= taille2 ; j++)
           ((Tenseur3BB*) (*d2_gijBB_tdt)(i,j))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d2_gijBB_tdt)(i,j)),plusZero);
          };
         if(ex.d_gijHH_tdt != NULL)
           { int taille = ex.d_gijHH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3HH*) ((*d_gijHH_tdt)(i)))->Affectation_2D_a_3D(*((Tenseur2HH*) (*ex.d_gijHH_tdt)(i)),plusZero);
          };
         if(ex.d_gradVmoyBB_tdt != NULL)
           { int taille = ex.d_gradVmoyBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gradVmoyBB_tdt)(i)),plusZero);
          };
         if(ex.d_gradVBB_tdt != NULL)
           { int taille = ex.d_gradVBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gradVBB_tdt)(i)))->Affectation_2D_a_3D(*((Tenseur2BB*) (*ex.d_gradVBB_tdt)(i)),plusZero);
          };
        
         //    -- les tableaux de pointeurs de scalaires
        if(ex.d_jacobien_tdt != NULL)
         { int taille = ex.d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};

// 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 Met_abstraite::Impli::Passage_de_Ordre3_vers_Ordre2(const Impli& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  // cas des tableaux : vérif
  //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  != NULL)&&(ex.d_giB_tdt == NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur non null et ex.d_giB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	if(d_giB_tdt != NULL)
	 { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
	     {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
		        << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d_giH_tdt  != NULL)&&(ex.d_giH_tdt == NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur non null et ex.d_giH_tdt est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_giH_tdt != NULL)
	 { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
	     {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
		        << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
    
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  != NULL)&&(ex.d_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur non null et ex.d_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d2_gijBB_tdt  != NULL)&&(ex.d2_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur non null et ex.d2_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d2_gijBB_tdt != NULL)
	 { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
	       || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
	     {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
		         << " et " << d2_gijBB_tdt->Taille2()
		        << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
				  << " et " << ex.d2_gijBB_tdt->Taille2()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
	  
   if((d_gijHH_tdt  != NULL)&&(ex.d_gijHH_tdt == NULL))	
     {cout << "\n *** erreur d_gijHH_tdt est un pointeur non null et ex.d_gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gijHH_tdt != NULL)
	 { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
	     {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
		        << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_t  != NULL)&&(ex.d_gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur non null et ex.d_gradVmoyBB_t est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gradVmoyBB_t != NULL)
	 { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_tdt  != NULL)&&(ex.d_gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur non null et ex.d_gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gradVmoyBB_tdt != NULL)
	 { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_t  != NULL)&&(ex.d_gradVBB_t == NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur non null et ex.d_gradVBB_t est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gradVBB_t != NULL)
	 { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
	     {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
		        << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_tdt  != NULL)&&(ex.d_gradVBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_gradVBB_tdt != NULL)
	 { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  

  //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  != NULL)&&(ex.d_jacobien_tdt == NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur non null et ex.d_jacobien_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	if(d_jacobien_tdt != NULL)
	 { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
	     {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
		        << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	  };		  
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur2BB*) gijBB_0)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_0));};
        if (gijHH_0 != NULL) {((Tenseur2HH*) gijHH_0)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_0));};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur2BB*) gijBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_t));};
        if (gijHH_t != NULL) {((Tenseur2HH*) gijHH_t)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_t));};
        if (gradVmoyBB_t != NULL) {((Tenseur2BB*) gradVmoyBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_t));};
        if(d_gradVmoyBB_t != NULL)
          { int taille = d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gradVmoyBB_t)(i)));
         };
        if(d_gradVBB_t != NULL)
          { int taille = d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVBB_t)(i)))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gradVBB_t)(i)));
         };
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
         if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
         if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
         if (gijBB_tdt != NULL) {((Tenseur2BB*) gijBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_tdt));};
         if (gijHH_tdt != NULL) {((Tenseur2HH*) gijHH_tdt)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_tdt));};
         if (gradVmoyBB_tdt != NULL) {((Tenseur2BB*) gradVmoyBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_tdt));};
         if (gradVBB_tdt != NULL) {((Tenseur2BB*) gradVBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVBB_tdt));};
         // on considère que c'est toujours ok pour les pointeurs de jacobiens
         (*jacobien_tdt) = (*ex.jacobien_tdt);
         // cas des tableaux
         //   -- les tableaux de pointeurs de base
         if(d_giB_tdt != NULL)
         { int taille = d_giB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
          };
         if(d_giH_tdt != NULL)
         { int taille = d_giH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
          };
        
         //    -- les tableaux de pointeurs de tenseurs
         if(d_gijBB_tdt != NULL)
           { int taille = d_gijBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur2BB*) ((*d_gijBB_tdt)(i)))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gijBB_tdt)(i)));
          };
         if(d2_gijBB_tdt != NULL)
           { int taille1 = d2_gijBB_tdt->Taille1();
           int taille2 = d2_gijBB_tdt->Taille2();
           for (int i=1;i<= taille1 ; i++)
             for (int j=1;j<= taille2 ; j++)
           ((Tenseur2BB*) ((*d2_gijBB_tdt)(i,j )))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d2_gijBB_tdt)(i,j )));
          };
         if(d_gijHH_tdt != NULL)
           { int taille = d_gijHH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur2HH*) ((*d_gijHH_tdt)(i)))->Affectation_3D_a_2D(*((Tenseur3HH*) (*ex.d_gijHH_tdt)(i)));
          };
         if(d_gradVmoyBB_tdt != NULL)
           { int taille = d_gradVmoyBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur2BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gradVmoyBB_tdt)(i)));
          };
         if(d_gradVBB_tdt != NULL)
           { int taille = d_gradVBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur2BB*) ((*d_gradVBB_tdt)(i)))->Affectation_3D_a_2D(*((Tenseur3BB*) (*ex.d_gradVBB_tdt)(i)));
          };
        
         //    -- les tableaux de pointeurs de scalaires
        if(d_jacobien_tdt != NULL)
         { int taille = d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 

};
      

// 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 Met_abstraite::Expli_t_tdt::Passage_de_Ordre1_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
 { // cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  // cas des tableaux : vérif
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  == NULL)&&(ex.d_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur null et ex.d_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };
	};  		  
   #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur3BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_t),plusZero);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVBB_tdt),plusZero);};
        
        if(ex.d_gijBB_tdt != NULL)
          { int taille = ex.d_gijBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          {((Tenseur3BB*) (*d_gijBB_tdt)(i))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gijBB_tdt)(i)),plusZero);};
      //    (*d_gijBB_tdt)(i) = (*ex.d_gijBB_tdt)(i);
         };
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};

// 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 Met_abstraite::Expli_t_tdt::Passage_de_Ordre3_vers_Ordre1(const Expli_t_tdt& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  // cas des tableaux : vérif
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  != NULL)&&(ex.d_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur non nul et ex.d_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };
	}
  #endif

  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur1BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_0),false);};
        if (gijHH_0 != NULL) {((Tenseur1HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_0),false);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur1BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_t),false);};
        if (gijHH_t != NULL) {((Tenseur1HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_t),false);};
        if (gradVmoyBB_t != NULL) {((Tenseur1BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_t),false);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (gijBB_tdt != NULL) {((Tenseur1BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_tdt),false);};
        if (gijHH_tdt != NULL) {((Tenseur1HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_tdt),false);};
        if (gradVmoyBB_tdt != NULL) {((Tenseur1BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_tdt),false);};
        if (gradVBB_tdt != NULL) {((Tenseur1BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVBB_tdt),false);};
        
        if(d_gijBB_tdt != NULL)
          { int taille = d_gijBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          {((Tenseur1BB*) (*d_gijBB_tdt)(i))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gijBB_tdt)(i)),false);};
      //    (*d_gijBB_tdt)(i) = (*ex.d_gijBB_tdt)(i);
         };
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};
      
// 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 Met_abstraite::Impli::Passage_de_Ordre1_vers_Ordre3(const Impli& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  // cas des tableaux : vérif
  //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  == NULL)&&(ex.d_giB_tdt != NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur null et ex.d_giB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_giB_tdt != NULL)
	 { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
	     {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
		        << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_giH_tdt  == NULL)&&(ex.d_giH_tdt != NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur null et ex.d_giH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_giH_tdt != NULL)
	 { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
	     {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
		        << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
    
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  == NULL)&&(ex.d_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur null et ex.d_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d2_gijBB_tdt  == NULL)&&(ex.d2_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur null et ex.d2_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d2_gijBB_tdt != NULL)
	 { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
	       || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
	     {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
		         << " et " << d2_gijBB_tdt->Taille2()
		        << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
				  << " et " << ex.d2_gijBB_tdt->Taille2()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
	  
   if((d_gijHH_tdt  == NULL)&&(ex.d_gijHH_tdt != NULL))	
     {cout << "\n *** erreur d_gijHH_tdt est un pointeur null et ex.d_gijHH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gijHH_tdt != NULL)
	 { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
	     {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
		        << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_t  == NULL)&&(ex.d_gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur null et ex.d_gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVmoyBB_t != NULL)
	 { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_tdt  == NULL)&&(ex.d_gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur null et ex.d_gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVmoyBB_tdt != NULL)
	 { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_t  == NULL)&&(ex.d_gradVBB_t != NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur null et ex.d_gradVBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVBB_t != NULL)
	 { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
	     {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
		        << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
  
 if((d_gradVBB_tdt  == NULL)&&(ex.d_gradVBB_tdt != NULL))	
     {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_gradVBB_tdt != NULL)
	 { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  

  //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  == NULL)&&(ex.d_jacobien_tdt != NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur null et ex.d_jacobien_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(ex.d_jacobien_tdt != NULL)
	 { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
	     {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
		        << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
	           << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	  };		  
	}
  #endif

  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur3BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_t),plusZero);};
        if(ex.d_gradVmoyBB_t != NULL)
          { int taille = ex.d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur3BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVmoyBB_t)(i)),plusZero);
         };
        if(ex.d_gradVBB_t != NULL)
          { int taille = ex.d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur3BB*) ((*d_gradVBB_t)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVBB_t)(i)),plusZero);
         };
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
         if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
         if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
         if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_tdt),plusZero);};
         if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_tdt),plusZero);};
         if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_tdt),plusZero);};
         if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVBB_tdt),plusZero);};
         // on considère que c'est toujours ok pour les pointeurs de jacobiens
         (*jacobien_tdt) = (*ex.jacobien_tdt);
         // cas des tableaux
         //   -- les tableaux de pointeurs de base
         if(ex.d_giB_tdt != NULL)
         { int taille = ex.d_giB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
          };
         if(ex.d_giH_tdt != NULL)
         { int taille = ex.d_giH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
          };
        
         //    -- les tableaux de pointeurs de tenseurs
         if(ex.d_gijBB_tdt != NULL)
           { int taille = ex.d_gijBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gijBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gijBB_tdt)(i)),plusZero);
          };
         if(ex.d2_gijBB_tdt != NULL)
           { int taille1 = ex.d2_gijBB_tdt->Taille1();
           int taille2 = ex.d2_gijBB_tdt->Taille2();
           for (int i=1;i<= taille1 ; i++)
             for (int j=1;j<= taille2 ; j++)
           ((Tenseur3BB*) (*d2_gijBB_tdt)(i,j))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d2_gijBB_tdt)(i,j)),plusZero);
          };
         if(ex.d_gijHH_tdt != NULL)
           { int taille = ex.d_gijHH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3HH*) ((*d_gijHH_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1HH*) (*ex.d_gijHH_tdt)(i)),plusZero);
          };
         if(ex.d_gradVmoyBB_tdt != NULL)
           { int taille = ex.d_gradVmoyBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVmoyBB_tdt)(i)),plusZero);
          };
         if(ex.d_gradVBB_tdt != NULL)
           { int taille = ex.d_gradVBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur3BB*) ((*d_gradVBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVBB_tdt)(i)),plusZero);
          };
        
         //    -- les tableaux de pointeurs de scalaires
        if(ex.d_jacobien_tdt != NULL)
         { int taille = ex.d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};

// 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 Met_abstraite::Impli::Passage_de_Ordre3_vers_Ordre1(const Impli& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  // cas des tableaux : vérif
  //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  != NULL)&&(ex.d_giB_tdt == NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur non null et ex.d_giB_tdt est null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	if(d_giB_tdt != NULL)
	 { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
	     {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
		        << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d_giH_tdt  != NULL)&&(ex.d_giH_tdt == NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur non null et ex.d_giH_tdt est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_giH_tdt != NULL)
	 { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
	     {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
		        << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
    
  //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  != NULL)&&(ex.d_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur non null et ex.d_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gijBB_tdt != NULL)
	 { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
	     {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
		        << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d2_gijBB_tdt  != NULL)&&(ex.d2_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur non null et ex.d2_gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d2_gijBB_tdt != NULL)
	 { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
	       || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
	     {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
		         << " et " << d2_gijBB_tdt->Taille2()
		        << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
				  << " et " << ex.d2_gijBB_tdt->Taille2()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
	  
   if((d_gijHH_tdt  != NULL)&&(ex.d_gijHH_tdt == NULL))	
     {cout << "\n *** erreur d_gijHH_tdt est un pointeur non null et ex.d_gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gijHH_tdt != NULL)
	 { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
	     {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
		        << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_t  != NULL)&&(ex.d_gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur non null et ex.d_gradVmoyBB_t est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gradVmoyBB_t != NULL)
	 { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d_gradVmoyBB_tdt  != NULL)&&(ex.d_gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur non null et ex.d_gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gradVmoyBB_tdt != NULL)
	 { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_t  != NULL)&&(ex.d_gradVBB_t == NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur non null et ex.d_gradVBB_t est  null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gradVBB_t != NULL)
	 { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
	     {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
		        << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
  
   if((d_gradVBB_tdt  != NULL)&&(ex.d_gradVBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_gradVBB_tdt != NULL)
	 { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
	     {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
		        << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  

  //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  != NULL)&&(ex.d_jacobien_tdt == NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur non null et ex.d_jacobien_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	if(d_jacobien_tdt != NULL)
	 { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
	     {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
		        << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
	           << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	  };		  
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur1BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_0),false);};
        if (gijHH_0 != NULL) {((Tenseur1HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_0),false);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur1BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_t),false);};
        if (gijHH_t != NULL) {((Tenseur1HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_t),false);};
        if (gradVmoyBB_t != NULL) {((Tenseur1BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_t),false);};
        if(d_gradVmoyBB_t != NULL)
          { int taille = d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur1BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gradVmoyBB_t)(i)),false);
         };
        if(d_gradVBB_t != NULL)
          { int taille = d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur1BB*) ((*d_gradVBB_t)(i)))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gradVBB_t)(i)),false);
         };
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
         if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
         if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
         if (gijBB_tdt != NULL) {((Tenseur1BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_tdt),false);};
         if (gijHH_tdt != NULL) {((Tenseur1HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_tdt),false);};
         if (gradVmoyBB_tdt != NULL) {((Tenseur1BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_tdt),false);};
         if (gradVBB_tdt != NULL) {((Tenseur1BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVBB_tdt),false);};
         // on considère que c'est toujours ok pour les pointeurs de jacobiens
         (*jacobien_tdt) = (*ex.jacobien_tdt);
         // cas des tableaux
         //   -- les tableaux de pointeurs de base
         if(d_giB_tdt != NULL)
         { int taille = d_giB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
          };
         if(d_giH_tdt != NULL)
         { int taille = d_giH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
          };
        
         //    -- les tableaux de pointeurs de tenseurs
         if(d_gijBB_tdt != NULL)
           { int taille = d_gijBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gijBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gijBB_tdt)(i)),false);
          };
         if(d2_gijBB_tdt != NULL)
           { int taille1 = d2_gijBB_tdt->Taille1();
           int taille2 = d2_gijBB_tdt->Taille2();
           for (int i=1;i<= taille1 ; i++)
             for (int j=1;j<= taille2 ; j++)
           ((Tenseur1BB*) ((*d2_gijBB_tdt)(i,j )))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d2_gijBB_tdt)(i,j )),false);
          };
         if(d_gijHH_tdt != NULL)
           { int taille = d_gijHH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1HH*) ((*d_gijHH_tdt)(i)))->Affectation_trans_dimension(*((Tenseur3HH*) (*ex.d_gijHH_tdt)(i)),false);
          };
         if(d_gradVmoyBB_tdt != NULL)
           { int taille = d_gradVmoyBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gradVmoyBB_tdt)(i)),false);
          };
         if(d_gradVBB_tdt != NULL)
           { int taille = d_gradVBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gradVBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur3BB*) (*ex.d_gradVBB_tdt)(i)),false);
          };
        
         //    -- les tableaux de pointeurs de scalaires
        if(d_jacobien_tdt != NULL)
         { int taille = d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};


    
// 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 Met_abstraite::Impli::Passage_de_Ordre1_vers_Ordre2(const Impli& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
   //  - les dimensions
   if (gijBB_0->Dimension() != 2)
    {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 2"
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (ex.gijBB_0->Dimension() != 1)
    {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 1"
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   //  - les pointeurs de vecteurs  
   if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
      {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
      {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
      {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
      {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
      {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
      {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   //  - les pointeurs de tenseurs
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   // cas des tableaux : vérif
   //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  == NULL)&&(ex.d_giB_tdt != NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur null et ex.d_giB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_giB_tdt != NULL)
    { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
        {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
            << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d_giH_tdt  == NULL)&&(ex.d_giH_tdt != NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur null et ex.d_giH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_giH_tdt != NULL)
    { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
        {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
            << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
   
   //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  == NULL)&&(ex.d_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur null et ex.d_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gijBB_tdt != NULL)
    { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
        {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
            << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d2_gijBB_tdt  == NULL)&&(ex.d2_gijBB_tdt != NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur null et ex.d2_gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d2_gijBB_tdt != NULL)
    { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
          || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
        {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
             << " et " << d2_gijBB_tdt->Taille2()
            << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
        << " et " << ex.d2_gijBB_tdt->Taille2()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
     
   if((d_gijHH_tdt  == NULL)&&(ex.d_gijHH_tdt != NULL))
       {cout << "\n *** erreur d_gijHH_tdt est un pointeur null et ex.d_gijHH_tdt est non null "
           << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gijHH_tdt != NULL)
    { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
        {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
            << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d_gradVmoyBB_t  == NULL)&&(ex.d_gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur null et ex.d_gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gradVmoyBB_t != NULL)
    { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
        {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
            << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d_gradVmoyBB_tdt  == NULL)&&(ex.d_gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur null et ex.d_gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gradVmoyBB_tdt != NULL)
    { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
        {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
            << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d_gradVBB_t  == NULL)&&(ex.d_gradVBB_t != NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur null et ex.d_gradVBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gradVBB_t != NULL)
    { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
        {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
            << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  
   if((d_gradVBB_tdt  == NULL)&&(ex.d_gradVBB_tdt != NULL))
       {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
           << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_gradVBB_tdt != NULL)
    { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
        {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
            << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
    };

   //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  == NULL)&&(ex.d_jacobien_tdt != NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur null et ex.d_jacobien_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(ex.d_jacobien_tdt != NULL)
    { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
        {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
            << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
              << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
     };		  
  }
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur2BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur2HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur2BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur2HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur2BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_t),plusZero);};
        if(ex.d_gradVmoyBB_t != NULL)
          { int taille = ex.d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVmoyBB_t)(i)),plusZero);
         };
        if(ex.d_gradVBB_t != NULL)
          { int taille = ex.d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVBB_t)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVBB_t)(i)),plusZero);
         };
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur2BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur2HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur2BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur2BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVBB_tdt),plusZero);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        // cas des tableaux
        //   -- les tableaux de pointeurs de base
        if(ex.d_giB_tdt != NULL)
        { int taille = ex.d_giB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
         };
        if(ex.d_giH_tdt != NULL)
        { int taille = ex.d_giH_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
         };
        
        //    -- les tableaux de pointeurs de tenseurs
        if(ex.d_gijBB_tdt != NULL)
          { int taille = ex.d_gijBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gijBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gijBB_tdt)(i)),plusZero);
         };
        if(ex.d2_gijBB_tdt != NULL)
          { int taille1 = ex.d2_gijBB_tdt->Taille1();
          int taille2 = ex.d2_gijBB_tdt->Taille2();
          for (int i=1;i<= taille1 ; i++)
            for (int j=1;j<= taille2 ; j++)
          ((Tenseur2BB*) (*d2_gijBB_tdt)(i,j))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d2_gijBB_tdt)(i,j)),plusZero);
         };
        if(ex.d_gijHH_tdt != NULL)
          { int taille = ex.d_gijHH_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2HH*) ((*d_gijHH_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1HH*) (*ex.d_gijHH_tdt)(i)),plusZero);
         };
        if(ex.d_gradVmoyBB_tdt != NULL)
          { int taille = ex.d_gradVmoyBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVmoyBB_tdt)(i)),plusZero);
         };
        if(ex.d_gradVBB_tdt != NULL)
          { int taille = ex.d_gradVBB_tdt->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur2BB*) ((*d_gradVBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur1BB*) (*ex.d_gradVBB_tdt)(i)),plusZero);
         };
        
        //    -- les tableaux de pointeurs de scalaires
        if(ex.d_jacobien_tdt != NULL)
         { int taille = ex.d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};

// 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 Met_abstraite::Impli::Passage_de_Ordre2_vers_Ordre1(const Impli& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
   //  - les dimensions
   if (gijBB_0->Dimension() != 1)
    {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 1"
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (ex.gijBB_0->Dimension() != 2)
    {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 2"
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   //  - les pointeurs de vecteurs  
   if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
      {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
      {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
      {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
      {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
      {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
      {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   //  - les pointeurs de tenseurs
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   // cas des tableaux : vérif
   //   -- les tableaux de pointeurs de base
   if((d_giB_tdt  != NULL)&&(ex.d_giB_tdt == NULL))	
     {cout << "\n *** erreur d_giB_tdt est un pointeur non null et ex.d_giB_tdt est null "
	        << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if(d_giB_tdt != NULL)
    { if (d_giB_tdt->Taille() != ex.d_giB_tdt->Taille())
        {cout << "\n *** erreur d_giB_tdt est tableau dont la taille "<< d_giB_tdt->Taille()
            << " est different de celle de ex.d_giB_tdt "<< ex.d_giB_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
  
   if((d_giH_tdt  != NULL)&&(ex.d_giH_tdt == NULL))	
     {cout << "\n *** erreur d_giH_tdt est un pointeur non null et ex.d_giH_tdt est  null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_giH_tdt != NULL)
    { if (d_giH_tdt->Taille() != ex.d_giH_tdt->Taille())
        {cout << "\n *** erreur d_giH_tdt est tableau dont la taille "<< d_giH_tdt->Taille()
            << " est different de celle de ex.d_giH_tdt "<< ex.d_giH_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
   
   //    -- les tableaux de pointeurs de tenseurs
   if((d_gijBB_tdt  != NULL)&&(ex.d_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d_gijBB_tdt est un pointeur non null et ex.d_gijBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gijBB_tdt != NULL)
    { if (d_gijBB_tdt->Taille() != ex.d_gijBB_tdt->Taille())
        {cout << "\n *** erreur d_gijBB_tdt est tableau dont la taille "<< d_gijBB_tdt->Taille()
            << " est different de celle de ex.d_gijBB_tdt "<< ex.d_gijBB_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
  
   if((d2_gijBB_tdt  != NULL)&&(ex.d2_gijBB_tdt == NULL))	
     {cout << "\n *** erreur d2_gijBB_tdt est un pointeur non null et ex.d2_gijBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d2_gijBB_tdt != NULL)
    { if (   (d2_gijBB_tdt->Taille1() != ex.d2_gijBB_tdt->Taille1())
          || (d2_gijBB_tdt->Taille2() != ex.d2_gijBB_tdt->Taille2()))
        {cout << "\n *** erreur d2_gijBB_tdt est tableau dont les tailles "<< d2_gijBB_tdt->Taille1() 
              << " et " << d2_gijBB_tdt->Taille2()
              << " sont differentes de celles de ex.d2_gijBB_tdt "<< ex.d2_gijBB_tdt->Taille1()
              << " et " << ex.d2_gijBB_tdt->Taille2()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
	  
   if((d_gijHH_tdt  != NULL)&&(ex.d_gijHH_tdt == NULL))	
     {cout << "\n *** erreur d_gijHH_tdt est un pointeur non null et ex.d_gijHH_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gijHH_tdt != NULL)
    { if (d_gijHH_tdt->Taille() != ex.d_gijHH_tdt->Taille())
        {cout << "\n *** erreur d_gijHH_tdt est tableau dont la taille "<< d_gijHH_tdt->Taille()
            << " est different de celle de ex.d_gijHH_tdt "<< ex.d_gijHH_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
  
   if((d_gradVmoyBB_t  != NULL)&&(ex.d_gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_t est un pointeur non null et ex.d_gradVmoyBB_t est  null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gradVmoyBB_t != NULL)
     { if (d_gradVmoyBB_t->Taille() != ex.d_gradVmoyBB_t->Taille())
         {cout << "\n *** erreur d_gradVmoyBB_t est tableau dont la taille "<< d_gradVmoyBB_t->Taille()
             << " est different de celle de ex.d_gradVmoyBB_t "<< ex.d_gradVmoyBB_t->Taille()
               << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
      };		  
  
   if((d_gradVmoyBB_tdt  != NULL)&&(ex.d_gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVmoyBB_tdt est un pointeur non null et ex.d_gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gradVmoyBB_tdt != NULL)
    { if (d_gradVmoyBB_tdt->Taille() != ex.d_gradVmoyBB_tdt->Taille())
        {cout << "\n *** erreur d_gradVmoyBB_tdt est tableau dont la taille "<< d_gradVmoyBB_tdt->Taille()
            << " est different de celle de ex.d_gradVmoyBB_tdt "<< ex.d_gradVmoyBB_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
  
   if((d_gradVBB_t  != NULL)&&(ex.d_gradVBB_t == NULL))	
     {cout << "\n *** erreur d_gradVBB_t est un pointeur non null et ex.d_gradVBB_t est  null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gradVBB_t != NULL)
    { if (d_gradVBB_t->Taille() != ex.d_gradVBB_t->Taille())
        {cout << "\n *** erreur d_gradVBB_t est tableau dont la taille "<< d_gradVBB_t->Taille()
            << " est different de celle de ex.d_gradVBB_t "<< ex.d_gradVBB_t->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  
  
   if((d_gradVBB_tdt  != NULL)&&(ex.d_gradVBB_tdt == NULL))	
     {cout << "\n *** erreur d_gradVBB_tdt est un pointeur null et ex.d_gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if(d_gradVBB_tdt != NULL)
    { if (d_gradVBB_tdt->Taille() != ex.d_gradVBB_tdt->Taille())
        {cout << "\n *** erreur d_gradVBB_tdt est tableau dont la taille "<< d_gradVBB_tdt->Taille()
            << " est different de celle de ex.d_gradVBB_tdt "<< ex.d_gradVBB_tdt->Taille()
              << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
     };		  

   //    -- les tableaux de pointeurs de scalaires
  
   if((d_jacobien_tdt  != NULL)&&(ex.d_jacobien_tdt == NULL))	
     {cout << "\n *** erreur d_jacobien_tdt est un pointeur non null et ex.d_jacobien_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if(d_jacobien_tdt != NULL)
    { if (d_jacobien_tdt->Taille() != ex.d_jacobien_tdt->Taille())
        {cout << "\n *** erreur d_jacobien_tdt est tableau dont la taille "<< d_jacobien_tdt->Taille()
            << " est different de celle de ex.d_jacobien_tdt "<< ex.d_jacobien_tdt->Taille()
              << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
     };		  
  }
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur1BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_0),false);};
        if (gijHH_0 != NULL) {((Tenseur1HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_0),false);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur1BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_t),false);};
        if (gijHH_t != NULL) {((Tenseur1HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_t),false);};
        if (gradVmoyBB_t != NULL) {((Tenseur1BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVmoyBB_t),false);};
        if(d_gradVmoyBB_t != NULL)
          { int taille = d_gradVmoyBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur1BB*) ((*d_gradVmoyBB_t)(i)))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d_gradVmoyBB_t)(i)),false);
         };
        if(d_gradVBB_t != NULL)
          { int taille = d_gradVBB_t->Taille();
          for (int i=1;i<= taille ; i++)
          ((Tenseur1BB*) ((*d_gradVBB_t)(i)))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d_gradVBB_t)(i)),false);
         };
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
         if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
         if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
         if (gijBB_tdt != NULL) {((Tenseur1BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_tdt),false);};
         if (gijHH_tdt != NULL) {((Tenseur1HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_tdt),false);};
         if (gradVmoyBB_tdt != NULL) {((Tenseur1BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVmoyBB_tdt),false);};
         if (gradVBB_tdt != NULL) {((Tenseur1BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVBB_tdt),false);};
         // on considère que c'est toujours ok pour les pointeurs de jacobiens
         (*jacobien_tdt) = (*ex.jacobien_tdt);
         // cas des tableaux
         //   -- les tableaux de pointeurs de base
         if(d_giB_tdt != NULL)
         { int taille = d_giB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giB_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giB_tdt)(i),plusZero);
          };
         if(d_giH_tdt != NULL)
         { int taille = d_giH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_giH_tdt)(i).Affectation_partielle(nb_vecteur_a_affecter, (*ex.d_giH_tdt)(i),plusZero);
          };
        
         //    -- les tableaux de pointeurs de tenseurs
         if(d_gijBB_tdt != NULL)
           { int taille = d_gijBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gijBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d_gijBB_tdt)(i)),false);
          };
         if(d2_gijBB_tdt != NULL)
           { int taille1 = d2_gijBB_tdt->Taille1();
           int taille2 = d2_gijBB_tdt->Taille2();
           for (int i=1;i<= taille1 ; i++)
             for (int j=1;j<= taille2 ; j++)
           ((Tenseur1BB*) ((*d2_gijBB_tdt)(i,j )))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d2_gijBB_tdt)(i,j )),false);
          };
         if(d_gijHH_tdt != NULL)
           { int taille = d_gijHH_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1HH*) ((*d_gijHH_tdt)(i)))->Affectation_trans_dimension(*((Tenseur2HH*) (*ex.d_gijHH_tdt)(i)),false);
          };
         if(d_gradVmoyBB_tdt != NULL)
           { int taille = d_gradVmoyBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gradVmoyBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d_gradVmoyBB_tdt)(i)),false);
          };
         if(d_gradVBB_tdt != NULL)
           { int taille = d_gradVBB_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           ((Tenseur1BB*) ((*d_gradVBB_tdt)(i)))->Affectation_trans_dimension(*((Tenseur2BB*) (*ex.d_gradVBB_tdt)(i)),false);
          };
        
         //    -- les tableaux de pointeurs de scalaires
        if(d_jacobien_tdt != NULL)
         { int taille = d_jacobien_tdt->Taille();
           for (int i=1;i<= taille ; i++)
           (*d_jacobien_tdt)(i) = (*ex.d_jacobien_tdt)(i);
          };
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};

//--------------------------- partie Umat ---------------------------

// 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 Met_abstraite::Umat_cont::Passage_de_Ordre2_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	  
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre2_vers_Ordre3(.."; Sortie(1);};
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_t),plusZero);};
         if (ex.gradVmoyBB_t != NULL) {((Tenseur3BB*) gradVmoyBB_t)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_t),plusZero);};
      }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_2D_a_3D(*((Tenseur2HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_2D_a_3D(*((Tenseur2BB*) ex.gradVBB_tdt),plusZero);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};

// 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 Met_abstraite::Umat_cont::Passage_de_Ordre3_vers_Ordre2(const Umat_cont& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 2) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 2"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	  
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};	
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre2(.."; Sortie(1);};
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 2; // on a 2 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur2BB*) gijBB_0)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_0));};
        if (gijHH_0 != NULL) {((Tenseur2HH*) gijHH_0)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_0));};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur2BB*) gijBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_t));};
        if (gijHH_t != NULL) {((Tenseur2HH*) gijHH_t)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_t));};
        if (gradVmoyBB_t != NULL) {((Tenseur2BB*) gradVmoyBB_t)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_t));};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (gijBB_tdt != NULL) {((Tenseur2BB*) gijBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gijBB_tdt));};
        if (gijHH_tdt != NULL) {((Tenseur2HH*) gijHH_tdt)->Affectation_3D_a_2D(*((Tenseur3HH*) ex.gijHH_tdt));};
        if (gradVmoyBB_tdt != NULL) {((Tenseur2BB*) gradVmoyBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVmoyBB_tdt));};
        if (gradVBB_tdt != NULL) {((Tenseur2BB*) gradVBB_tdt)->Affectation_3D_a_2D(*((Tenseur3BB*) ex.gradVBB_tdt));};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
      }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};
      
      
// 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 Met_abstraite::Umat_cont::Passage_de_Ordre1_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
     {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
     {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
	        << "\n Passage_de_Ordre1_vers_Ordre3(.."; Sortie(1);};
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur3BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur3HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur3BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur3HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur3BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_t),plusZero);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur3BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur3HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur3BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur3BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVBB_tdt),plusZero);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};

// 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 Met_abstraite::Umat_cont::Passage_de_Ordre3_vers_Ordre1(const Umat_cont& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
  //  - les dimensions
  if (gijBB_0->Dimension() != 1)
	  {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 1"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (ex.gijBB_0->Dimension() != 3) 
	  {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 3"
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de vecteurs  
  if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
     {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
     {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
     {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
     {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
     {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
     {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
  //  - les pointeurs de tenseurs  			  
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre3_vers_Ordre1(.."; Sortie(1);};
	}
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur1BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_0),false);};
        if (gijHH_0 != NULL) {((Tenseur1HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_0),false);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur1BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_t),false);};
        if (gijHH_t != NULL) {((Tenseur1HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_t),false);};
        if (gradVmoyBB_t != NULL) {((Tenseur1BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_t),false);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (gijBB_tdt != NULL) {((Tenseur1BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gijBB_tdt),false);};
        if (gijHH_tdt != NULL) {((Tenseur1HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur3HH*) ex.gijHH_tdt),false);};
        if (gradVmoyBB_tdt != NULL) {((Tenseur1BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVmoyBB_tdt),false);};
        if (gradVBB_tdt != NULL) {((Tenseur1BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur3BB*) ex.gradVBB_tdt),false);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
};

// 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 Met_abstraite::Umat_cont::Passage_de_Ordre1_vers_Ordre2(const Umat_cont& ex,bool plusZero,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
   //  - les dimensions
   if (gijBB_0->Dimension() != 2)
    {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 2"
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (ex.gijBB_0->Dimension() != 1)
    {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 1"
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   //  - les pointeurs de vecteurs  
   if (	(giB_0 == NULL)&&(ex.giB_0 != NULL))	
      {cout << "\n *** erreur giB_0 est un pointeur null et ex.giB_0 est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_0 == NULL)&&(ex.giH_0 != NULL))	
      {cout << "\n *** erreur giH_0 est un pointeur null et ex.giH_0 est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giB_t == NULL)&&(ex.giB_t != NULL))	
      {cout << "\n *** erreur giB_t est un pointeur null et ex.giB_t est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_t == NULL)&&(ex.giH_t != NULL))	
      {cout << "\n *** erreur giH_t est un pointeur null et ex.giH_t est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giB_tdt == NULL)&&(ex.giB_tdt != NULL))	
      {cout << "\n *** erreur giB_tdt est un pointeur null et ex.giB_tdt est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if (	(giH_tdt == NULL)&&(ex.giH_tdt != NULL))	
      {cout << "\n *** erreur giH_tdt est un pointeur null et ex.giH_tdt est non null "
          << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   //  - les pointeurs de tenseurs
   if((gijBB_0  == NULL)&&(ex.gijBB_0 != NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur null et ex.gijBB_0 est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_0  == NULL)&&(ex.gijHH_0 != NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur null et ex.gijHH_0 est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_t  == NULL)&&(ex.gijBB_t != NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur null et ex.gijBB_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_t  == NULL)&&(ex.gijHH_t != NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur null et ex.gijHH_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijBB_tdt  == NULL)&&(ex.gijBB_tdt != NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur null et ex.gijBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gijHH_tdt  == NULL)&&(ex.gijHH_tdt != NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur null et ex.gijHH_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_t  == NULL)&&(ex.gradVmoyBB_t != NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur null et ex.gradVmoyBB_t est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVmoyBB_tdt  == NULL)&&(ex.gradVmoyBB_tdt != NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur null et ex.gradVmoyBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
   if((gradVBB_tdt  == NULL)&&(ex.gradVBB_tdt != NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur null et ex.gradVBB_tdt est non null "
         << "\n Passage_de_Ordre1_vers_Ordre2(.."; Sortie(1);};
  }
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {
        if (ex.giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (ex.giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (ex.gijBB_0 != NULL) {((Tenseur2BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_0),plusZero);};
        if (ex.gijHH_0 != NULL) {((Tenseur2HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_0),plusZero);};
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {
        if (ex.giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (ex.giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (ex.gijBB_t != NULL) {((Tenseur2BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_t),plusZero);};
        if (ex.gijHH_t != NULL) {((Tenseur2HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_t),plusZero);};
        if (ex.gradVmoyBB_t != NULL) {((Tenseur2BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_t),plusZero);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {
        if (ex.giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (ex.giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (ex.gijBB_tdt != NULL) {((Tenseur2BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gijBB_tdt),plusZero);};
        if (ex.gijHH_tdt != NULL) {((Tenseur2HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur1HH*) ex.gijHH_tdt),plusZero);};
        if (ex.gradVmoyBB_tdt != NULL) {((Tenseur2BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVmoyBB_tdt),plusZero);};
        if (ex.gradVBB_tdt != NULL) {((Tenseur2BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur1BB*) ex.gradVBB_tdt),plusZero);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };
 
};

// 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 Met_abstraite::Umat_cont::Passage_de_Ordre2_vers_Ordre1(const Umat_cont& ex,int type_recopie)
{ 
 #ifdef MISE_AU_POINT
  {// cas des grandeurs hors tableaux : vérif
   //  - les dimensions
   if (gijBB_0->Dimension() != 1)
    {cout << "\n *** erreur l'ordre de this ("<<gijBB_0->Dimension() <<") est different de 1"
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (ex.gijBB_0->Dimension() != 2)
    {cout << "\n *** erreur l'ordre de ex ("<<ex.gijBB_0->Dimension() <<") est different de 2"
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   //  - les pointeurs de vecteurs  
   if (	(giB_0 != NULL)&&(ex.giB_0 == NULL))	
      {cout << "\n *** erreur giB_0 est un pointeur non nul et ex.giB_0 est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_0 != NULL)&&(ex.giH_0 == NULL))	
      {cout << "\n *** erreur giH_0 est un pointeur non nul et ex.giH_0 est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giB_t != NULL)&&(ex.giB_t == NULL))	
      {cout << "\n *** erreur giB_t est un pointeur non nul et ex.giB_t est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_t != NULL)&&(ex.giH_t == NULL))	
      {cout << "\n *** erreur giH_t est un pointeur non nul et ex.giH_t est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giB_tdt != NULL)&&(ex.giB_tdt == NULL))	
      {cout << "\n *** erreur giB_tdt est un pointeur non nul et ex.giB_tdt est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if (	(giH_tdt != NULL)&&(ex.giH_tdt == NULL))	
      {cout << "\n *** erreur giH_tdt est un pointeur non nul et ex.giH_tdt est null "
          << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   //  - les pointeurs de tenseurs
   if((gijBB_0  != NULL)&&(ex.gijBB_0 == NULL))	
     {cout << "\n *** erreur gijBB_0 est un pointeur non nul et ex.gijBB_0 est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_0  != NULL)&&(ex.gijHH_0 == NULL))	
     {cout << "\n *** erreur gijHH_0 est un pointeur non nul et ex.gijHH_0 est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_t  != NULL)&&(ex.gijBB_t == NULL))	
     {cout << "\n *** erreur gijBB_t est un pointeur non nul et ex.gijBB_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_t  != NULL)&&(ex.gijHH_t == NULL))	
     {cout << "\n *** erreur gijHH_t est un pointeur non nul et ex.gijHH_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijBB_tdt  != NULL)&&(ex.gijBB_tdt == NULL))	
     {cout << "\n *** erreur gijBB_tdt est un pointeur non nul et ex.gijBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gijHH_tdt  != NULL)&&(ex.gijHH_tdt == NULL))	
     {cout << "\n *** erreur gijHH_tdt est un pointeur non nul et ex.gijHH_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_t  != NULL)&&(ex.gradVmoyBB_t == NULL))	
     {cout << "\n *** erreur gradVmoyBB_t est un pointeur non nul et ex.gradVmoyBB_t est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVmoyBB_tdt  != NULL)&&(ex.gradVmoyBB_tdt == NULL))	
     {cout << "\n *** erreur gradVmoyBB_tdt est un pointeur non nul et ex.gradVmoyBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
   if((gradVBB_tdt  != NULL)&&(ex.gradVBB_tdt == NULL))	
     {cout << "\n *** erreur gradVBB_tdt est un pointeur non nul et ex.gradVBB_tdt est null "
	        << "\n Passage_de_Ordre2_vers_Ordre1(.."; Sortie(1);};
  }
  #endif
  // cas des bases
  int nb_vecteur_a_affecter = 1; // on a 1 vecteurs a affecter des bases de ex a this: = ici tous les vecteurs
  bool plusZero=false; // ici ne sert à rien car this est plus petit que ex, donc on ne peut pas complèter
  switch (type_recopie)
   {
     case 0 :// = 0 -> on transfert les grandeurs à 0, t et tdt
       {if (giB_0 != NULL) {giB_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_0),plusZero);};
        if (giH_0 != NULL) {giH_0->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_0),plusZero);};
        if (gijBB_0 != NULL) {((Tenseur1BB*) gijBB_0)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_0),false);};
        if (gijHH_0 != NULL) {((Tenseur1HH*) gijHH_0)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_0),false);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_0) = (*ex.jacobien_0);
       }
     case 1 :// = 1 -> on transfert les grandeurs à t et tdt
       {if (giB_t != NULL) {giB_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_t),plusZero);};
        if (giH_t != NULL) {giH_t->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_t),plusZero);};
        if (gijBB_t != NULL) {((Tenseur1BB*) gijBB_t)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_t),false);};
        if (gijHH_t != NULL) {((Tenseur1HH*) gijHH_t)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_t),false);};
        if (gradVmoyBB_t != NULL) {((Tenseur1BB*) gradVmoyBB_t)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVmoyBB_t),false);};
       }
     case 2 :// = 2 -> on transfert les grandeurs à tdt
       {if (giB_tdt != NULL) {giB_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giB_tdt),plusZero);};
        if (giH_tdt != NULL) {giH_tdt->Affectation_partielle(nb_vecteur_a_affecter, (*ex.giH_tdt),plusZero);};
        if (gijBB_tdt != NULL) {((Tenseur1BB*) gijBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gijBB_tdt),false);};
        if (gijHH_tdt != NULL) {((Tenseur1HH*) gijHH_tdt)->Affectation_trans_dimension(*((Tenseur2HH*) ex.gijHH_tdt),false);};
        if (gradVmoyBB_tdt != NULL) {((Tenseur1BB*) gradVmoyBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVmoyBB_tdt),false);};
        if (gradVBB_tdt != NULL) {((Tenseur1BB*) gradVBB_tdt)->Affectation_trans_dimension(*((Tenseur2BB*) ex.gradVBB_tdt),false);};
        // on considère que c'est toujours ok pour les pointeurs de jacobiens
        (*jacobien_tdt) = (*ex.jacobien_tdt);
        break;
       }
     default: { cout << "\n cas d'un transfert non reconnu: "
                     << " type_recopie= "<< type_recopie
                     << "\n    ";
                Sortie(1);
                break;
              }
   };

};


      
