2893 lines
171 KiB
C++
Executable file
2893 lines
171 KiB
C++
Executable file
|
|
// 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;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|