905 lines
57 KiB
C++
905 lines
57 KiB
C++
/*! \file Met_abstraite_stuc_donnees.h
|
|
\brief def des structures de données de passage d'informations pour les métriques
|
|
*/
|
|
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
/************************************************************************
|
|
* *
|
|
* DATE: 15/01/97 *
|
|
* $ *
|
|
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
|
* $ *
|
|
* PROJET: Herezh++ *
|
|
* $ *
|
|
************************************************************************
|
|
* deuxième partie du fichier Met_abstraite.h
|
|
* contient en fait toutes les structures de données de passage d'informations
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
|
* VERIFICATION: *
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* ! ! ! ! *
|
|
* *
|
|
* $ *
|
|
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
|
* MODIFICATIONS:
|
|
* *
|
|
* ! date ! auteur ! but ! *
|
|
* ------------------------------------------------------------ *
|
|
* *
|
|
* $ *
|
|
* *
|
|
************************************************************************/
|
|
|
|
|
|
// deuxième partie du fichier Met_abstraite.h
|
|
// contient en fait toutes les structures de données de passage d'informations
|
|
|
|
// CLASSE CONTENEUR : cas explicite entre 0 et t, toutes les grandeurs sont a 0 ou t
|
|
// les données sont publiques
|
|
class Expli_t_tdt;
|
|
/// @} // end of group
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class Expli
|
|
{ public :
|
|
Expli () : // constructeur par défaut
|
|
giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),
|
|
gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gradVBB_t(NULL),gradVmoyBB_t(NULL),d_gijBB_t(NULL),
|
|
jacobien_t(NULL),jacobien_0(NULL)
|
|
{};
|
|
Expli // constructeur normal
|
|
(BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH *ggiH_t,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,
|
|
TenseurHH * ggijHH_t,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVBB_t,
|
|
Tableau <TenseurBB *>* gd_gijBB_t,double* gjacobien_t,double* gjacobien_0) :
|
|
giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t)
|
|
,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t),gradVBB_t(ggradVBB_t)
|
|
,gradVmoyBB_t(ggradVmoyBB_t),d_gijBB_t(gd_gijBB_t)
|
|
,jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
|
|
{};
|
|
Expli (const Expli& ex) : // constructeur de copie
|
|
giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),
|
|
gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
|
|
,gradVBB_t(ex.gradVBB_t),gradVmoyBB_t(ex.gradVmoyBB_t),d_gijBB_t(ex.d_gijBB_t),
|
|
jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
|
|
{};
|
|
Expli& operator= (const Expli& ex) // surcharge d'affectation
|
|
{giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;
|
|
gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
|
|
gradVmoyBB_t=ex.gradVmoyBB_t;gradVBB_t=ex.gradVBB_t,d_gijBB_t=ex.d_gijBB_t;
|
|
jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
|
|
return *this;
|
|
};
|
|
// une fonction qui permet de produire un objet Expli_t_tdt mais en mettant seulement les
|
|
// grandeur calculées à t commune à Expli_t_tdt
|
|
Expli_t_tdt T_dans_tdt() const
|
|
{return Expli_t_tdt(giB_0,giH_0,giB_t,giH_t,NULL,NULL,gijBB_0,gijHH_0,gijBB_t,gijHH_t
|
|
,NULL,NULL,gradVmoyBB_t,NULL,NULL,NULL,NULL,jacobien_t,jacobien_0);
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH *ggiH_t,
|
|
TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH * ggijHH_t,TenseurBB* ggradVmoyBB_t,
|
|
TenseurBB * ggradVBB_t,Tableau <TenseurBB *>* gd_gijBB_t,double* gjacobien_t,double* gjacobien_0)
|
|
{giB_0=ggiB_0;giH_0=ggiH_0; giB_t=ggiB_t;giH_t=ggiH_t;
|
|
gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;
|
|
gradVmoyBB_t=ggradVmoyBB_t;gradVBB_t=ggradVBB_t,d_gijBB_t=gd_gijBB_t;
|
|
jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
|
|
};
|
|
// mise à jour des grandeurs à 0 sauf les variations (pas de tableau et pas à t)
|
|
// à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
|
|
// non de pointeur !)
|
|
void Recup_grandeur_0(BaseB & ggiB_0,BaseH & ggiH_0,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0
|
|
,double& gjacobien_0)
|
|
{*giB_0=ggiB_0;*giH_0=ggiH_0;*gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;
|
|
*jacobien_0=gjacobien_0;
|
|
};
|
|
|
|
// variables
|
|
BaseB * giB_0; BaseH * giH_0; BaseB * giB_t; BaseH * giH_t;
|
|
TenseurBB * gijBB_0; TenseurHH* gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t;
|
|
TenseurBB * gradVmoyBB_t;TenseurBB * gradVBB_t;Tableau <TenseurBB *>* d_gijBB_t;
|
|
double *jacobien_t;double *jacobien_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// --- CLASSE CONTENEUR : cas d'une procédure Umat
|
|
// les variables sont publiques
|
|
class Umat_cont
|
|
{ public :
|
|
Umat_cont () : // constructeur par défaut
|
|
giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),giH_tdt(NULL)
|
|
,gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
|
|
,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL)
|
|
,jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL)
|
|
{};
|
|
Umat_cont // constructeur normal
|
|
(BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t, BaseH * ggiH_t,BaseB * ggiB_tdt,BaseH *ggiH_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0
|
|
) :
|
|
giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),giH_tdt(ggiH_tdt)
|
|
,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t)
|
|
,gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
|
|
,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt)
|
|
,jacobien_tdt(gjacobien_tdt),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
|
|
{};
|
|
Umat_cont (const Umat_cont& ex) : // constructeur de copie
|
|
giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),giH_tdt(ex.giH_tdt)
|
|
,gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
|
|
,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
|
|
,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt)
|
|
,jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
|
|
{};
|
|
Umat_cont& operator= (const Umat_cont& ex) // surcharge d'affectation
|
|
{ giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;giH_tdt=ex.giH_tdt;
|
|
gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
|
|
gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
|
|
gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
|
|
jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
|
|
return *this;
|
|
};
|
|
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t
|
|
,BaseB * ggiB_tdt,BaseH *ggiH_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0, TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0)
|
|
{ giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;giH_tdt=ggiH_tdt;
|
|
gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
|
|
gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
|
|
jacobien_tdt=gjacobien_tdt;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
|
|
};
|
|
// méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre2_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre2(const Umat_cont& ex,int type_recopie);
|
|
|
|
// méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre1_vers_Ordre3(const Umat_cont& ex,bool plusZero,int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre1(const Umat_cont& ex,int type_recopie);
|
|
|
|
// méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre1_vers_Ordre2(const Umat_cont& ex,bool plusZero,int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre2, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre2
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre2_vers_Ordre1(const Umat_cont& ex,int type_recopie);
|
|
|
|
// ------ variables --------
|
|
BaseB * giB_0; BaseH * giH_0; BaseB * giB_t;BaseH * giH_t;BaseB * giB_tdt;BaseH * giH_tdt;
|
|
TenseurBB * gijBB_0; TenseurHH * gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t;
|
|
TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt;
|
|
TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt;
|
|
double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
// --- fin CLASSE CONTENEUR : cas d'une procédure Umat
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// CLASSE CONTENEUR : cas explicite entre 0 et tdt, les grandeurs sont a 0 ou t et tdt
|
|
// les variables sont publiques
|
|
class Expli_t_tdt
|
|
{ public :
|
|
Expli_t_tdt () : // constructeur par défaut
|
|
giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),giH_tdt(NULL)
|
|
,gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
|
|
,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL),d_gijBB_tdt(NULL)
|
|
,jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL)
|
|
{};
|
|
Expli_t_tdt // constructeur normal
|
|
(BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH *ggiH_t,BaseB * ggiB_tdt,BaseH *ggiH_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0) :
|
|
giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),giH_tdt(ggiH_tdt)
|
|
,gijBB_0(ggijBB_0),gijHH_0(ggijHH_0),gijBB_t(ggijBB_t),gijHH_t(ggijHH_t)
|
|
,gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
|
|
,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt)
|
|
,d_gijBB_tdt(gd_gijBB_tdt)
|
|
,jacobien_tdt(gjacobien_tdt),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0)
|
|
{};
|
|
Expli_t_tdt (const Expli_t_tdt& ex) : // constructeur de copie
|
|
giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),giH_tdt(ex.giH_tdt)
|
|
,gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
|
|
,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
|
|
,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt)
|
|
,d_gijBB_tdt(ex.d_gijBB_tdt)
|
|
,jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0)
|
|
{};
|
|
Expli_t_tdt& operator= (const Expli_t_tdt& ex) // surcharge d'affectation
|
|
{giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;giH_tdt=ex.giH_tdt;
|
|
gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
|
|
gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
|
|
gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
|
|
d_gijBB_tdt=ex.d_gijBB_tdt;
|
|
jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
|
|
return *this;};
|
|
|
|
// une fonction qui permet de produire un objet expli mais en mettant les grandeurs
|
|
// à tdt de l'objet expli_t_tdt à la place des grandeurs à t de l'objet expli
|
|
Expli Tdt_dans_t() const
|
|
{ return Expli(giB_0,giH_0,giB_tdt,giH_tdt,gijBB_0,gijHH_0,gijBB_tdt,gijHH_tdt,gradVmoyBB_tdt
|
|
,gradVBB_tdt,d_gijBB_tdt,jacobien_tdt,jacobien_0);
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t
|
|
,BaseB * ggiB_tdt,BaseH *ggiH_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH* ggijHH_0,TenseurBB * ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB * ggijBB_tdt,TenseurHH * ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,double* gjacobien_tdt,double* gjacobien_t,double* gjacobien_0)
|
|
{giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;giH_tdt=ggiH_tdt;
|
|
gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
|
|
gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
|
|
d_gijBB_tdt=gd_gijBB_tdt;
|
|
jacobien_tdt=gjacobien_tdt;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
|
|
};
|
|
// mise à jour des grandeurs à 0 et à t sauf les variations (pas de tableau et pas à tdt)
|
|
// à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
|
|
// non de pointeur !)
|
|
void Recup_grandeur_0_t(BaseB & ggiB_0,BaseH & ggiH_0,BaseB & ggiB_t,BaseH& ggiH_t
|
|
,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0,TenseurBB& ggijBB_t,TenseurHH& ggijHH_t
|
|
,TenseurBB & ,double& gjacobien_t,double& gjacobien_0)
|
|
{*giB_0=ggiB_0;*giH_0=ggiH_0;*giB_t=ggiB_t;*giH_t=ggiH_t;
|
|
*gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;*gijBB_t=ggijBB_t;*gijHH_t=ggijHH_t;
|
|
*jacobien_t=gjacobien_t;*jacobien_0=gjacobien_0;//*gradVmoyBB_t=ggradVmoyBB_t;
|
|
};
|
|
// méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre2_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero, int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre2(const Expli_t_tdt& ex, int type_recopie);
|
|
|
|
// méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre1_vers_Ordre3(const Expli_t_tdt& ex,bool plusZero, int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre1(const Expli_t_tdt& ex, int type_recopie);
|
|
|
|
// récupération d'une instance Umat_cont, contenant les grandeurs associés à this
|
|
Umat_cont & Recup_Umat_cont(Umat_cont& ex)const
|
|
{ ex.giB_0 = giB_0;ex.giH_0= giH_0;ex.giB_t=giB_t;ex.giH_t=giH_t;ex.giB_tdt=giB_tdt;ex.giH_tdt=giH_tdt;
|
|
ex.gijBB_0=gijBB_0; ex.gijHH_0=gijHH_0; ex.gijBB_t=gijBB_t;ex.gijHH_t=gijHH_t;
|
|
ex.gijBB_tdt=gijBB_tdt;ex.gijHH_tdt=gijHH_tdt;
|
|
ex.gradVmoyBB_t=gradVmoyBB_t;ex.gradVmoyBB_tdt=gradVmoyBB_tdt;ex.gradVBB_tdt=gradVBB_tdt;
|
|
ex.jacobien_tdt=jacobien_tdt;ex.jacobien_t=jacobien_t;ex.jacobien_0=jacobien_0;
|
|
return ex;
|
|
};
|
|
|
|
// ------ variables
|
|
BaseB * giB_0; BaseH * giH_0; BaseB * giB_t;BaseH* giH_t;BaseB * giB_tdt;BaseH * giH_tdt;
|
|
TenseurBB * gijBB_0; TenseurHH* gijHH_0; TenseurBB * gijBB_t;TenseurHH * gijHH_t;
|
|
TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt;
|
|
TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt;
|
|
Tableau <TenseurBB *>* d_gijBB_tdt;
|
|
double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// CLASSE CONTENEUR : cas implicite ----------------------------------------------------------------
|
|
// calcul des termes de la classe impli
|
|
class Impli
|
|
{ public :
|
|
Impli () : // constructeur par défaut
|
|
giB_0(NULL),giH_0(NULL),giB_t(NULL),giH_t(NULL),giB_tdt(NULL),d_giB_tdt(NULL),giH_tdt(NULL)
|
|
,d_giH_tdt(NULL),gijBB_0(NULL),gijHH_0(NULL),gijBB_t(NULL),gijHH_t(NULL),gijBB_tdt(NULL),gijHH_tdt(NULL)
|
|
,gradVmoyBB_t(NULL),gradVmoyBB_tdt(NULL),gradVBB_tdt(NULL),d_gijBB_tdt(NULL),d2_gijBB_tdt(NULL)
|
|
,d_gijHH_tdt(NULL), jacobien_tdt(NULL),jacobien_t(NULL),jacobien_0(NULL),d_jacobien_tdt(NULL)
|
|
,d_gradVmoyBB_t(NULL),d_gradVmoyBB_tdt(NULL),d_gradVBB_t(NULL),d_gradVBB_tdt(NULL)
|
|
{};
|
|
Impli // constructeur normal
|
|
(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH * ggiH_t, BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
|
|
,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
|
|
,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t
|
|
,TenseurHH* ggijHH_t,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
|
|
,Tableau <TenseurHH *>* gd_gijHH_tdt
|
|
,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
|
|
) :
|
|
giB_0(ggiB_0),giH_0(ggiH_0),giB_t(ggiB_t),giH_t(ggiH_t),giB_tdt(ggiB_tdt),d_giB_tdt(d_ggiB_tdt),
|
|
giH_tdt(ggiH_tdt),d_giH_tdt(d_ggiH_tdt),
|
|
gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
|
|
,gijBB_t(ggijBB_t),gijHH_t(ggijHH_t),gijBB_tdt(ggijBB_tdt),gijHH_tdt(ggijHH_tdt)
|
|
,gradVmoyBB_t(ggradVmoyBB_t),gradVmoyBB_tdt(ggradVmoyBB_tdt),gradVBB_tdt(ggradVBB_tdt),
|
|
d_gijBB_tdt(gd_gijBB_tdt),d2_gijBB_tdt(gd2_gijBB_tdt),d_gijHH_tdt(gd_gijHH_tdt),
|
|
jacobien_tdt(gjacobien),jacobien_t(gjacobien_t),jacobien_0(gjacobien_0),d_jacobien_tdt(gd_jacobien_tdt)
|
|
,d_gradVmoyBB_t(gd_gradVmoyBB_t),d_gradVmoyBB_tdt(gd_gradVmoyBB_tdt)
|
|
,d_gradVBB_t(gd_gradVBB_t),d_gradVBB_tdt(gd_gradVBB_tdt)
|
|
{};
|
|
Impli (const Impli& ex) : // constructeur de copie
|
|
giB_0(ex.giB_0),giH_0(ex.giH_0),giB_t(ex.giB_t),giH_t(ex.giH_t),giB_tdt(ex.giB_tdt),d_giB_tdt(ex.d_giB_tdt)
|
|
,giH_tdt(ex.giH_tdt),d_giH_tdt(ex.d_giH_tdt),
|
|
gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0),gijBB_t(ex.gijBB_t),gijHH_t(ex.gijHH_t)
|
|
,gijBB_tdt(ex.gijBB_tdt),gijHH_tdt(ex.gijHH_tdt)
|
|
,gradVmoyBB_t(ex.gradVmoyBB_t),gradVmoyBB_tdt(ex.gradVmoyBB_tdt),gradVBB_tdt(ex.gradVBB_tdt),
|
|
d_gijBB_tdt(ex.d_gijBB_tdt),d2_gijBB_tdt(ex.d2_gijBB_tdt),d_gijHH_tdt(ex.d_gijHH_tdt),
|
|
jacobien_tdt(ex.jacobien_tdt),jacobien_t(ex.jacobien_t),jacobien_0(ex.jacobien_0),d_jacobien_tdt(ex.d_jacobien_tdt)
|
|
,d_gradVmoyBB_t(ex.d_gradVmoyBB_t),d_gradVmoyBB_tdt(ex.d_gradVmoyBB_tdt)
|
|
,d_gradVBB_t(ex.d_gradVBB_t),d_gradVBB_tdt(ex.d_gradVBB_tdt)
|
|
{};
|
|
|
|
Impli& operator= (const Impli& ex) // surcharge d'affectation
|
|
{giB_0=ex.giB_0;giH_0=ex.giH_0;giB_t=ex.giB_t;giH_t=ex.giH_t;giB_tdt=ex.giB_tdt;d_giB_tdt=ex.d_giB_tdt;
|
|
giH_tdt=ex.giH_tdt;d_giH_tdt=ex.d_giH_tdt;
|
|
gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0; gijBB_t=ex.gijBB_t;gijHH_t=ex.gijHH_t;
|
|
gijBB_tdt=ex.gijBB_tdt;gijHH_tdt=ex.gijHH_tdt;
|
|
gradVmoyBB_t=ex.gradVmoyBB_t;gradVmoyBB_tdt=ex.gradVmoyBB_tdt;gradVBB_tdt=ex.gradVBB_tdt;
|
|
d_gijBB_tdt=ex.d_gijBB_tdt;d2_gijBB_tdt=ex.d2_gijBB_tdt;d_gijHH_tdt=ex.d_gijHH_tdt;
|
|
jacobien_tdt=ex.jacobien_tdt;jacobien_t=ex.jacobien_t;jacobien_0=ex.jacobien_0;
|
|
d_jacobien_tdt=ex.d_jacobien_tdt;
|
|
d_gradVmoyBB_t=ex.d_gradVmoyBB_t;d_gradVmoyBB_tdt=ex.d_gradVmoyBB_tdt;
|
|
d_gradVBB_t=ex.d_gradVBB_t;d_gradVBB_tdt=ex.d_gradVBB_tdt;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur
|
|
(BaseB * ggiB_0,BaseH * ggiH_0,BaseB * ggiB_t,BaseH* ggiH_t
|
|
,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
|
|
,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
|
|
,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
|
|
,Tableau <TenseurHH *>* gd_gijHH_tdt
|
|
,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
|
|
)
|
|
{giB_0=ggiB_0;giH_0=ggiH_0;giB_t=ggiB_t;giH_t=ggiH_t;giB_tdt=ggiB_tdt;d_giB_tdt=d_ggiB_tdt;
|
|
giH_tdt=ggiH_tdt;d_giH_tdt=d_ggiH_tdt;
|
|
gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;gijBB_t=ggijBB_t;gijHH_t=ggijHH_t;
|
|
gijBB_tdt=ggijBB_tdt;gijHH_tdt=ggijHH_tdt;
|
|
gradVmoyBB_t=ggradVmoyBB_t;gradVmoyBB_tdt=ggradVmoyBB_tdt;gradVBB_tdt=ggradVBB_tdt;
|
|
d_gijBB_tdt=gd_gijBB_tdt;d2_gijBB_tdt=gd2_gijBB_tdt;d_gijHH_tdt=gd_gijHH_tdt;
|
|
jacobien_tdt=gjacobien;jacobien_t=gjacobien_t;jacobien_0=gjacobien_0;
|
|
d_jacobien_tdt=gd_jacobien_tdt;
|
|
d_gradVmoyBB_t=gd_gradVmoyBB_t;d_gradVmoyBB_tdt=gd_gradVmoyBB_tdt;
|
|
d_gradVBB_t=gd_gradVBB_t;d_gradVBB_tdt=gd_gradVBB_tdt;
|
|
};
|
|
// mise à jour des grandeurs à 0 et à t sauf les variations (pas de tableau et pas à tdt)
|
|
// à partir de grandeurs stockées par ailleurs (il s'agit ici donc d'affectation de contenu et
|
|
// non de pointeur !)
|
|
void Recup_grandeur_0_t(BaseB & ggiB_0,BaseH & ggiH_0,BaseB & ggiB_t,BaseH& ggiH_t
|
|
,TenseurBB& ggijBB_0,TenseurHH& ggijHH_0,TenseurBB& ggijBB_t,TenseurHH& ggijHH_t
|
|
,TenseurBB & ,double& gjacobien_t,double& gjacobien_0
|
|
)
|
|
{ *giB_0=ggiB_0;*giH_0=ggiH_0;*giB_t=ggiB_t;*giH_t=ggiH_t;
|
|
*gijBB_0=ggijBB_0;*gijHH_0=ggijHH_0;*gijBB_t=ggijBB_t;*gijHH_t=ggijHH_t;
|
|
*jacobien_t=gjacobien_t;*jacobien_0=gjacobien_0;//*gradVmoyBB_t=ggradVmoyBB_t;
|
|
};
|
|
// méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre2_vers_Ordre3(const Impli& ex,bool plusZero, int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre2_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 2, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre2_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre2(const Impli& ex, int type_recopie);
|
|
|
|
// méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 3, this doit donc avoir des tenseur d'ordre 3
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre1_vers_Ordre3(const Impli& ex,bool plusZero, int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 3 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre3, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 3, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre3
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre3_vers_Ordre1(const Impli& ex, int type_recopie);
|
|
|
|
// méthode permettant un passage des grandeurs de l'ordre 1 à l'ordre 2, this doit donc avoir des tenseur d'ordre 2
|
|
// il y a recopie des valeurs et bool plusZero, indique s'il faut ou non complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
|
|
// on se réfère donc aux grandeurs de l'argument : ex
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre1_vers_Ordre2(const Impli& ex,bool plusZero, int type_recopie);
|
|
// méthode permettant un passage des grandeurs de l'ordre 2 à l'ordre 1, this doit donc avoir des tenseur d'ordre 1
|
|
// il y a recopie des valeurs: contrairement à la méthode Passage_de_Ordre1_vers_Ordre2, comme la cible est plus petite que l'origine
|
|
// on n'a pas besoin de complèter avec des 0
|
|
// --->>> pour les tableaux il faut qu'ils aient la même dimension, sinon erreur générée dans le cas de mise_au_point
|
|
// --->>> pour pointeur, s'ils sont non-nuls au niveau de l'ordre 1, ils doivent également être non nul au niveau de l'ordre 2, sinon erreur
|
|
// c'est donc les éléments de this, qui servent de modèle, contrairement à la méthode duale:Passage_de_Ordre1_vers_Ordre2
|
|
// pour laquelle c'était les éléments de ex qui servaient de modèle
|
|
// type recopie : = 0 -> on transfert les grandeurs à 0, t et tdt
|
|
// = 1 -> on transfert les grandeurs à t et tdt
|
|
// = 2 -> on transfert les grandeurs à tdt
|
|
void Passage_de_Ordre2_vers_Ordre1(const Impli& ex, int type_recopie);
|
|
|
|
// récupération d'une instance Umat_cont, contenant les grandeurs associés à this
|
|
Umat_cont & Recup_Umat_cont(Umat_cont& ex)const
|
|
{ ex.giB_0 = giB_0;ex.giH_0= giH_0;ex.giB_t=giB_t;ex.giH_t=giH_t;ex.giB_tdt=giB_tdt;ex.giH_tdt=giH_tdt;
|
|
ex.gijBB_0=gijBB_0; ex.gijHH_0=gijHH_0; ex.gijBB_t=gijBB_t;ex.gijHH_t=gijHH_t;
|
|
ex.gijBB_tdt=gijBB_tdt;ex.gijHH_tdt=gijHH_tdt;
|
|
ex.gradVmoyBB_t=gradVmoyBB_t;ex.gradVmoyBB_tdt=gradVmoyBB_tdt;ex.gradVBB_tdt=gradVBB_tdt;
|
|
ex.jacobien_tdt=jacobien_tdt;ex.jacobien_t=jacobien_t;ex.jacobien_0=jacobien_0;
|
|
return ex;
|
|
};
|
|
|
|
// ---------- variables -------- :
|
|
|
|
BaseB * giB_0; BaseH * giH_0; BaseB * giB_t; BaseH * giH_t;BaseB * giB_tdt;Tableau <BaseB> * d_giB_tdt;
|
|
BaseH * giH_tdt;Tableau <BaseH> * d_giH_tdt;
|
|
TenseurBB * gijBB_0; TenseurHH * gijHH_0;
|
|
TenseurBB * gijBB_t ; TenseurHH * gijHH_t ;TenseurBB * gijBB_tdt;TenseurHH * gijHH_tdt;
|
|
TenseurBB * gradVmoyBB_t;TenseurBB * gradVmoyBB_tdt;TenseurBB * gradVBB_tdt; Tableau <TenseurBB *> * d_gijBB_tdt;
|
|
Tableau2 <TenseurBB *> * d2_gijBB_tdt;
|
|
Tableau <TenseurHH *>* d_gijHH_tdt;
|
|
double* jacobien_tdt;double* jacobien_t;double* jacobien_0;
|
|
Vecteur* d_jacobien_tdt;
|
|
Tableau <TenseurBB * >* d_gradVmoyBB_t;Tableau <TenseurBB * >* d_gradVmoyBB_tdt;
|
|
Tableau <TenseurBB * >* d_gradVBB_t;Tableau <TenseurBB * >* d_gradVBB_tdt;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// classe pour le calcul de gijHH_0 et de giH_0 juste après le calcul implicite
|
|
// (sinon il y a erreur)
|
|
class gijHH_0_et_giH_0
|
|
{ public:
|
|
gijHH_0_et_giH_0 () : giH_0(NULL),gijHH_0(NULL) {}; // constructeur par défaut
|
|
gijHH_0_et_giH_0 // constructeur normal
|
|
(BaseH * ggiH_0,TenseurHH * ggijHH_0) : giH_0(ggiH_0),gijHH_0(ggijHH_0) {};
|
|
gijHH_0_et_giH_0 (const gijHH_0_et_giH_0& ex) : // constructeur de copie
|
|
giH_0(ex.giH_0),gijHH_0(ex.gijHH_0) {};
|
|
gijHH_0_et_giH_0& operator= (const gijHH_0_et_giH_0& ex) // surcharge d'affectation
|
|
{giH_0=ex.giH_0;gijHH_0=ex.gijHH_0;return *this;};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(BaseH * ggiH_0,TenseurHH * ggijHH_0)
|
|
{giH_0=ggiH_0;gijHH_0=ggijHH_0;};
|
|
// ------ variables --------
|
|
TenseurHH * gijHH_0; BaseH * giH_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// CLASSE CONTENEUR : cas de la dynamique
|
|
// calcul des termes de la classe Dynamiq
|
|
class Dynamiq
|
|
{ public :
|
|
Dynamiq () : // constructeur par défaut
|
|
giB_0(NULL),giB_tdt(NULL),gijBB_0(NULL),gijBB_tdt(NULL)
|
|
,jacobien_tdt(NULL),jacobien_0(NULL)
|
|
{};
|
|
Dynamiq // constructeur normal
|
|
(BaseB * ggiB_0,BaseB * ggiB_tdt,TenseurBB * ggijBB_0,TenseurBB * ggijBB_tdt
|
|
,double* gjacobien_tdt,double* gjacobien_0
|
|
) :
|
|
giB_0(ggiB_0),giB_tdt(ggiB_tdt),gijBB_0(ggijBB_0),gijBB_tdt(ggijBB_tdt)
|
|
,jacobien_tdt(gjacobien_tdt),jacobien_0(gjacobien_0)
|
|
{};
|
|
Dynamiq (const Dynamiq& ex) : // constructeur de copie
|
|
giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),gijBB_0(ex.gijBB_0),gijBB_tdt(ex.gijBB_tdt)
|
|
,jacobien_tdt(ex.jacobien_tdt),jacobien_0(ex.jacobien_0)
|
|
{};
|
|
|
|
Dynamiq& operator= (const Dynamiq& ex) // surcharge d'affectation
|
|
{ giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;gijBB_0=ex.gijBB_0;gijBB_tdt=ex.gijBB_tdt;
|
|
jacobien_tdt=ex.jacobien_tdt;jacobien_0=ex.jacobien_0;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(BaseB * ggiB_0,BaseB * ggiB_tdt,TenseurBB * ggijBB_0,TenseurBB * ggijBB_tdt
|
|
,double* gjacobien_tdt,double* gjacobien_0)
|
|
{ giB_0=ggiB_0;giB_tdt=ggiB_tdt;gijBB_0=ggijBB_0;gijBB_tdt=ggijBB_tdt;
|
|
jacobien_tdt=gjacobien_tdt;jacobien_0=gjacobien_0;
|
|
};
|
|
|
|
// ------ variables --------
|
|
BaseB * giB_0; BaseB * giB_tdt;
|
|
TenseurBB * gijBB_0; TenseurBB * gijBB_tdt;
|
|
double* jacobien_tdt;double* jacobien_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class flambe_lin : public Impli
|
|
{ public :
|
|
flambe_lin(): // constructeur par défaut
|
|
Impli()
|
|
{};
|
|
flambe_lin // constructeur avec tous les paramètres
|
|
(BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH * ggiH_t,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
|
|
,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
|
|
,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t
|
|
,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
|
|
,Tableau <TenseurHH *>* gd_gijHH_tdt
|
|
,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
|
|
):
|
|
Impli(ggiB_0,ggiH_0,ggiB_t,ggiH_t,ggiB_tdt,d_ggiB_tdt,ggiH_tdt,d_ggiH_tdt
|
|
,ggijBB_0,ggijHH_0,ggijBB_t,ggijHH_t,ggijBB_tdt,ggijHH_tdt,ggradVmoyBB_t,ggradVmoyBB_tdt,ggradVBB_tdt
|
|
,gd_gijBB_tdt,gd2_gijBB_tdt,gd_gijHH_tdt,gjacobien,gjacobien_t,gjacobien_0,gd_jacobien_tdt
|
|
,gd_gradVmoyBB_t,gd_gradVmoyBB_tdt
|
|
,gd_gradVBB_t,gd_gradVBB_tdt
|
|
)
|
|
{};
|
|
|
|
flambe_lin(const flambe_lin & ex) : // constructeur de copie
|
|
Impli(ex)
|
|
{};
|
|
flambe_lin& operator= (const flambe_lin& ex) // surcharge d'affectation
|
|
{ this->Impli::operator= ((Impli&) ex);
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur
|
|
(BaseB * ggiB_0,BaseH * ggiH_0, BaseB * ggiB_t,BaseH* ggiH_t
|
|
,BaseB * ggiB_tdt,Tableau <BaseB> * d_ggiB_tdt
|
|
,BaseH *ggiH_tdt,Tableau <BaseH> * d_ggiH_tdt
|
|
,TenseurBB* ggijBB_0,TenseurHH* ggijHH_0,TenseurBB* ggijBB_t,TenseurHH* ggijHH_t,TenseurBB* ggijBB_tdt,TenseurHH* ggijHH_tdt
|
|
,TenseurBB * ggradVmoyBB_t,TenseurBB * ggradVmoyBB_tdt,TenseurBB * ggradVBB_tdt
|
|
,Tableau <TenseurBB *>* gd_gijBB_tdt,Tableau2 <TenseurBB *> * gd2_gijBB_tdt
|
|
,Tableau <TenseurHH *>* gd_gijHH_tdt
|
|
,double* gjacobien,double* gjacobien_t,double* gjacobien_0,Vecteur* gd_jacobien_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVmoyBB_t,Tableau <TenseurBB * >* gd_gradVmoyBB_tdt
|
|
,Tableau <TenseurBB * >* gd_gradVBB_t,Tableau <TenseurBB * >* gd_gradVBB_tdt
|
|
)
|
|
{ Impli::Mise_a_jour_grandeur(ggiB_0,ggiH_0,ggiB_t,ggiH_t,ggiB_tdt,d_ggiB_tdt,ggiH_tdt,d_ggiH_tdt
|
|
,ggijBB_0,ggijHH_0,ggijBB_t,ggijHH_t,ggijBB_tdt,ggijHH_tdt,ggradVmoyBB_t,ggradVmoyBB_tdt,ggradVBB_tdt
|
|
,gd_gijBB_tdt,gd2_gijBB_tdt,gd_gijHH_tdt,gjacobien,gjacobien_t,gjacobien_0,gd_jacobien_tdt
|
|
,gd_gradVmoyBB_t,gd_gradVmoyBB_tdt
|
|
,gd_gradVBB_t,gd_gradVBB_tdt);
|
|
};
|
|
|
|
// ------- variables (idem Impli)
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class InfoImp
|
|
{public :
|
|
InfoImp(): // constructeur par défaut
|
|
M0(NULL),Mtdt(NULL),giB_0(NULL),giB_tdt(NULL),giH_0(NULL),giH_tdt(NULL),gijHH_tdt(NULL),gijBB_tdt(NULL)
|
|
,gijBB_0(NULL),gijHH_0(NULL)
|
|
{};
|
|
InfoImp // constructeur avec toutes les variables
|
|
(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0):
|
|
M0(gM0),Mtdt(gMtdt),giB_0(ggiB_0),giB_tdt(ggiB_tdt),giH_0(ggiH_0),giH_tdt(ggiH_tdt)
|
|
,gijHH_tdt(ggijHH_tdt),gijBB_tdt(ggijBB_tdt),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
|
|
{};
|
|
InfoImp (const InfoImp & ex): // constructeur de copie
|
|
M0(ex.M0),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),giH_0(ex.giH_0),giH_tdt(ex.giH_tdt)
|
|
,gijHH_tdt(ex.gijHH_tdt),gijBB_tdt(ex.gijBB_tdt),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
|
|
{};
|
|
InfoImp& operator= (const InfoImp& ex) // surcharge d'affectation
|
|
{ M0=ex.M0;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;giH_0=ex.giH_0;giH_tdt=ex.giH_tdt;
|
|
gijHH_tdt=ex.gijHH_tdt;gijBB_tdt=ex.gijBB_tdt;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
|
|
{ M0=gM0;Mtdt=gMtdt;giB_0=ggiB_0;giB_tdt=ggiB_tdt;giH_0=ggiH_0;giH_tdt=ggiH_tdt;
|
|
gijHH_tdt=ggijHH_tdt;gijBB_tdt=ggijBB_tdt;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
|
|
};
|
|
|
|
// ------ variables --------
|
|
Coordonnee *M0; Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_tdt;
|
|
BaseH * giH_0; BaseH * giH_tdt;TenseurHH * gijHH_tdt;TenseurBB * gijBB_tdt;
|
|
TenseurBB * gijBB_0;TenseurHH * gijHH_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class InfoExp_t
|
|
{ public :
|
|
InfoExp_t(): // constructeur par défaut
|
|
M0(NULL),Mt(NULL),giB_0(NULL),giB_t(NULL),giH_0(NULL),giH_t(NULL),gijHH_t(NULL),gijBB_t(NULL)
|
|
,gijBB_0(NULL),gijHH_0(NULL)
|
|
{};
|
|
InfoExp_t // constructeur avec toutes les variables
|
|
(Coordonnee *gM0,Coordonnee *gMt,BaseB * ggiB_0,BaseB * ggiB_t,
|
|
BaseH * ggiH_0, BaseH * ggiH_t,TenseurHH * ggijHH_t,TenseurBB * ggijBB_t
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0):
|
|
M0(gM0),Mt(gMt),giB_0(ggiB_0),giB_t(ggiB_t),giH_0(ggiH_0),giH_t(ggiH_t)
|
|
,gijHH_t(ggijHH_t),gijBB_t(ggijBB_t),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
|
|
{};
|
|
InfoExp_t (const InfoExp_t & ex): // constructeur de copie
|
|
M0(ex.M0),Mt(ex.Mt),giB_0(ex.giB_0),giB_t(ex.giB_t),giH_0(ex.giH_0),giH_t(ex.giH_t)
|
|
,gijHH_t(ex.gijHH_t),gijBB_t(ex.gijBB_t),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
|
|
{};
|
|
InfoExp_t& operator= (const InfoExp_t& ex) // surcharge d'affectation
|
|
{ M0=ex.M0;Mt=ex.Mt;giB_0=ex.giB_0;giB_t=ex.giB_t;giH_0=ex.giH_0;giH_t=ex.giH_t;
|
|
gijHH_t=ex.gijHH_t;gijBB_t=ex.gijBB_t;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMt,BaseB * ggiB_0,BaseB * ggiB_t,
|
|
BaseH * ggiH_0, BaseH * ggiH_t,TenseurHH * ggijHH_t,TenseurBB * ggijBB_t
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
|
|
{ M0=gM0;Mt=gMt;giB_0=ggiB_0;giB_t=ggiB_t;giH_0=ggiH_0;giH_t=ggiH_t;
|
|
gijHH_t=ggijHH_t;gijBB_t=ggijBB_t;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
|
|
};
|
|
|
|
// ------ variables --------
|
|
Coordonnee *M0; Coordonnee *Mt;BaseB * giB_0; BaseB * giB_t;
|
|
BaseH * giH_0; BaseH * giH_t;TenseurHH * gijHH_t;TenseurBB * gijBB_t;
|
|
TenseurBB * gijBB_0;TenseurHH * gijHH_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class InfoExp_tdt
|
|
{ public :
|
|
InfoExp_tdt(): // constructeur par défaut
|
|
M0(NULL),Mtdt(NULL),giB_0(NULL),giB_tdt(NULL),giH_0(NULL),giH_tdt(NULL),gijHH_tdt(NULL),gijBB_tdt(NULL)
|
|
,gijBB_0(NULL),gijHH_0(NULL)
|
|
{};
|
|
InfoExp_tdt // constructeur avec toutes les variables
|
|
(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0
|
|
):
|
|
M0(gM0),Mtdt(gMtdt),giB_0(ggiB_0),giB_tdt(ggiB_tdt),giH_0(ggiH_0),giH_tdt(ggiH_tdt)
|
|
,gijHH_tdt(ggijHH_tdt),gijBB_tdt(ggijBB_tdt),gijBB_0(ggijBB_0),gijHH_0(ggijHH_0)
|
|
{};
|
|
InfoExp_tdt (const InfoExp_tdt & ex): // constructeur de copie
|
|
M0(ex.M0),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_tdt(ex.giB_tdt),giH_0(ex.giH_0),giH_tdt(ex.giH_tdt)
|
|
,gijHH_tdt(ex.gijHH_tdt),gijBB_tdt(ex.gijBB_tdt),gijBB_0(ex.gijBB_0),gijHH_0(ex.gijHH_0)
|
|
{};
|
|
InfoExp_tdt& operator= (const InfoExp_tdt& ex) // surcharge d'affectation
|
|
{ M0=ex.M0;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_tdt=ex.giB_tdt;giH_0=ex.giH_0;giH_tdt=ex.giH_tdt;
|
|
gijHH_tdt=ex.gijHH_tdt;gijBB_tdt=ex.gijBB_tdt;gijBB_0=ex.gijBB_0;gijHH_0=ex.gijHH_0;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_tdt,TenseurHH * ggijHH_tdt,TenseurBB * ggijBB_tdt
|
|
,TenseurBB * ggijBB_0,TenseurHH * ggijHH_0)
|
|
{ M0=gM0;Mtdt=gMtdt;giB_0=ggiB_0;giB_tdt=ggiB_tdt;giH_0=ggiH_0;giH_tdt=ggiH_tdt;
|
|
gijHH_tdt=ggijHH_tdt;gijBB_tdt=ggijBB_tdt;gijBB_0=ggijBB_0;gijHH_0=ggijHH_0;
|
|
};
|
|
|
|
// ------ variables --------
|
|
Coordonnee *M0; Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_tdt;
|
|
BaseH * giH_0; BaseH * giH_tdt;TenseurHH * gijHH_tdt;TenseurBB * gijBB_tdt;
|
|
TenseurBB * gijBB_0;TenseurHH * gijHH_0;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
class Info0_t_tdt
|
|
{ public :
|
|
Info0_t_tdt(): // constructeur par défaut
|
|
M0(NULL),Mt(NULL),Mtdt(NULL),giB_0(NULL),giB_t(NULL),giB_tdt(NULL)
|
|
,giH_0(NULL),giH_t(NULL),giH_tdt(NULL)
|
|
{};
|
|
Info0_t_tdt // constructeur avec toutes les variables
|
|
(Coordonnee *gM0,Coordonnee *gMt,Coordonnee *gMtdt,BaseB * ggiB_0,BaseB * ggiB_t,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_t,BaseH * ggiH_tdt):
|
|
M0(gM0),Mt(gMt),Mtdt(gMtdt),giB_0(ggiB_0),giB_t(ggiB_t),giB_tdt(ggiB_tdt)
|
|
,giH_0(ggiH_0),giH_t(ggiH_t),giH_tdt(ggiH_tdt)
|
|
{};
|
|
Info0_t_tdt (const Info0_t_tdt & ex): // constructeur de copie
|
|
M0(ex.M0),Mt(ex.Mt),Mtdt(ex.Mtdt),giB_0(ex.giB_0),giB_t(ex.giB_t),giB_tdt(ex.giB_tdt)
|
|
,giH_0(ex.giH_0),giH_t(ex.giH_t),giH_tdt(ex.giH_tdt)
|
|
{};
|
|
Info0_t_tdt& operator= (const Info0_t_tdt& ex) // surcharge d'affectation
|
|
{ M0=ex.M0;Mt=ex.Mt;Mtdt=ex.Mtdt;giB_0=ex.giB_0;giB_t=ex.giB_t;giB_tdt=ex.giB_tdt;
|
|
giH_0=ex.giH_0;giH_t=ex.giH_t;giH_tdt=ex.giH_tdt;
|
|
return *this;
|
|
};
|
|
// mise à jour des grandeurs
|
|
void Mise_a_jour_grandeur(Coordonnee *gM0,Coordonnee *gMt,Coordonnee *gMtdt
|
|
,BaseB * ggiB_0,BaseB * ggiB_t,BaseB * ggiB_tdt,
|
|
BaseH * ggiH_0, BaseH * ggiH_t,BaseH * ggiH_tdt)
|
|
{ M0=gM0;Mt=gMt;Mtdt=gMtdt;giB_0=ggiB_0;giB_t=ggiB_t;giB_tdt=ggiB_tdt;
|
|
giH_0=ggiH_0;giH_t=ggiH_t;giH_tdt=ggiH_tdt;
|
|
};
|
|
|
|
// ------ variables --------
|
|
Coordonnee *M0; Coordonnee *Mt;Coordonnee *Mtdt;BaseB * giB_0; BaseB * giB_t;BaseB * giB_tdt;
|
|
BaseH * giH_0; BaseH * giH_t;BaseH * giH_tdt;
|
|
};
|
|
/// @} // end of group
|
|
|
|
|
|
/// @addtogroup groupe_des_metrique
|
|
/// @{
|
|
///
|
|
|
|
// CLASSE CONTENEUR : pour le transfert d'information grandeurs à t = 0, t et tdt et
|
|
// toutes les métriques associées
|
|
// la classe Umat_cont, contient les mêmes informations qui sont utiles
|
|
// dans l'utilisation d'information déjà calculées
|
|
typedef Umat_cont Info_et_metrique_0_t_tdt;
|
|
|
|
/// @} // end of group
|
|
|
|
|
|
|
|
|
|
|