// 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 "TypeConsTens.h"
using namespace std; //introduces namespace std
#include <cmath>
// =========================================================================================
// vu la taille des executables le fichier est decompose en trois
// le premier : Met_abstraite1s2.cp concerne les constructeurs, destructeur et
// la gestion des variables
// le deuxième : Met_abstraite2s2.cp concerne le calcul des méthodes publiques
// le troisième: Met_abstraite2s2.cp concerne le calcul des méthodes privées
// =========================================================================================
// ***********$ il faut utiliser des références pour optimiser l'opérateur parenthèse
/// ceci dans la plupart des routines gourmandes !!!!!!!!!!!!!!!!!!!!
// METHODES PUBLIQUES :
// ------------------------ calculs ----------------------------------------
// cas explicite à t, toutes les grandeurs sont a 0 ou t
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t sont calculées
const Met_abstraite::Expli& Met_abstraite::Cal_explicit_t
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane, const Mat_pleine& dphi,int nombre_noeud
,const Vecteur& phi,bool premier_calcul)
{ if (premier_calcul)
{ Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_gijBB_0 (); // metrique base naturelle
Calcul_gijHH_0 (); // composantes controvariantes à 0
Calcul_giH_0(); // base duale
Jacobien_0(); // jacobien initiale
};
// calcul des grandeurs à t
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
/// Calcul_gradVBB_moyen_t(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes à t
Jacobien_t(); // calcul du jacobien a t
Calcul_giH_t(); // base duale à t
D_giB_t(dphi,nombre_noeud,phi); //
// DgradVmoyBB_t(); // variation du gradient moyen
D_gijBB_t(); //variation de la metrique en BB
if (gradV_instantane)
{
#ifdef MISE_AU_POINT
if (!(tab_noeud(1)->Existe_ici(V1))) // on vérifie que les vitesses existent aux noeuds
{ cout << "\nErreur : pas de ddl de vitesse pour le calcul du gradient instantanne ";
cout << "\n Met_abstraite::Cal_explicit_t(..." << endl;
Sortie(1);
}
#endif
Calcul_gradVBB_t(tab_noeud,dphi,nombre_noeud); // calcul du gradient de vitesse
};
// liberation des tenseurs intermediaires
LibereTenseur();
// return ex;
return ex_expli;
};
// cas explicite à tdt, toutes les grandeurs sont a 0 ou tdt
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t sont calculées
const Met_abstraite::Expli_t_tdt& Met_abstraite::Cal_explicit_tdt
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane, const Mat_pleine& dphi
,int nombre_noeud,const Vecteur& phi,bool premier_calcul)
{ if (premier_calcul)
{ Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
Calcul_gijBB_0 (); // metrique base naturelle
//---debug
// string tutut;
// cout << "/n Met_abstraite::Cal_explicit_tdt: une donnee "; cin >> tutut;
//-- fin debug
Calcul_gijHH_0 (); // composantes controvariantes à 0
Calcul_giH_0(); // base duale
Jacobien_0(); // jacobien initiale
/// Calcul_gradVBB_moyen_t(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
Calcul_gijBB_t (); // metrique à t
//---debug
// cout << "/n Met_abstraite::Cal_explicit_tdt: une donnee "; cin >> tutut;
//-- fin debug
Calcul_gijHH_t (); // metrique à t
//---debug
// string titit;
// cout << "/n Met_abstraite::Cal_explicit_tdt: apres Calcul_gijHH_t (); "; cin >> tutut;
//-- fin debug
Calcul_giH_t(); // base duale
Jacobien_t(); // jacobien à t
};
// calcul des grandeurs à tdt
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
/// Calcul_gradVBB_moyen_tdt(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
Calcul_gijBB_tdt (); // "
//---debug
// string tutut;
// cout << "/n Met_abstraite::Cal_explicit_tdt: une donnee "; cin >> tutut;
//-- fin debug
Calcul_gijHH_tdt (); // composantes controvariantes à tdt
//---debug
// string titit;
// cout << "/n Met_abstraite::Cal_explicit_tdt: apres Calcul_gijHH_tdt (); "; cin >> tutut;
//-- fin debug
Jacobien_tdt(); // calcul du jacobien a tdt
////---debug
// #ifdef MISE_AU_POINT
// if (ParaGlob::NiveauImpression() > 2)
// if ((jacobien_tdt <= 0.)|| (std::isinf(jacobien_tdt))||( std::isnan(jacobien_tdt))) // vérif du jacobien
// {int nbn = tab_noeud.Taille();
// cout << "\n *** attention jacobien negatif (Met_abstraite::Cal_explicit_tdt(..) , info sur les noeuds: \n";
// for (int i=1;i<=nbn;i++)
// tab_noeud(i)->Affiche(cout);
// };
// #endif
////--- fin debug
Calcul_giH_tdt(); // base duale à tdt
D_giB_tdt(dphi,nombre_noeud,phi); //
D_gijBB_tdt(); //variation de la metrique en BB
if (gradV_instantane)
{
#ifdef MISE_AU_POINT
if (!(tab_noeud(1)->Existe_ici(V1))) // on vérifie que les vitesses existent aux noeuds
{ cout << "\nErreur : pas de ddl de vitesse pour le calcul du gradient instantanne ";
cout << "\n Met_abstraite::Cal_explicit_tdt(..." << endl;
Sortie(1);
}
#endif
Calcul_gradVBB_tdt(tab_noeud,dphi,nombre_noeud); // calcul du gradient de vitesse
};
// liberation des tenseurs intermediaires
LibereTenseur();
//---debug
// string titit;
// cout << "/n Met_abstraite::Cal_explicit_tdt: apres LibereTenseur(); "; cin >> tutut;
//-- fin debug
return ex_expli_t_tdt;
};
// cas implicite, toutes les grandeurs sont a 0 ou t+dt
// lorsque avec_D est false alors il n'y a pas de calcul des variations seconde de la métrique
// gradV_instantane : true : calcul du gradient de vitesse instantannée
// premier_calcul : true : cas d'un premier calcul -> toutes les grandeurs sont calculées
// false: uniquement les grandeurs à t sont calculées
// avec_var_Xi : par défaut true, si false indique que l'on ne calcule pas les variations / au ddl Xi
const Met_abstraite::Impli& Met_abstraite::Cal_implicit
( const Tableau<Noeud *>& tab_noeud,bool gradV_instantane, const Mat_pleine& dphi,
int nombre_noeud,const Vecteur& phi,bool premier_calcul,bool avec_var_Xi)
{if (premier_calcul)
{Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_gijBB_0 (); // metrique base naturelle
Calcul_gijHH_0 (); // composantes controvariantes à 0
Calcul_giH_0(); // base duale
Jacobien_0(); // jacobien initiale
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
/// Calcul_gradVBB_moyen_t(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
/// gradVmoyBB_t(dphi); // calcul variation du gradient moyen à t
Calcul_gijBB_t (); // métrique a t
////--- debug
//cout << "\n debug Met_abstraite::Cal_implicit ";
//cout << "\n gijBB_t= "; gijBB_t->Ecriture(cout);
//cout << endl;
////--- fin debug
Calcul_gijHH_t (); // métrique a t
Calcul_giH_t(); // base duale à t
Jacobien_t(); // jacobien à t
}
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
/// Calcul_gradVBB_moyen_tdt(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
/// DgradVmoyBB_tdt(dphi); // calcul variation du gradient moyen à tdt
Calcul_gijBB_tdt (); // de la métrique finale
Calcul_gijHH_tdt (); // composantes controvariantes
Jacobien_tdt(); // calcul du jacobien a tdt
Calcul_giH_tdt(); // base duale
if (avec_var_Xi)
{ D_giB_tdt(dphi,nombre_noeud,phi); //
D_gijBB_tdt(); //variation de la metrique en BB et de la variation du gradient de vitesse moyen à tdt
D_giH_tdt(); // variation de la base duale
D_gijHH_tdt(); //variation de la metrique en HH
Djacobien_tdt(); // variation du jacobien
};
////---debug
//cout << "\n base 0 " << (*giB_0);
//cout << "\n base t " << (*giB_t);
//cout << "\n base tdt " << (*giB_tdt);
////--- fin debug
if (gradV_instantane)
{
#ifdef MISE_AU_POINT
if (!(tab_noeud(1)->Existe_ici(V1))) // on vérifie que les vitesses existent aux noeuds
{ cout << "\nErreur : pas de ddl de vitesse pour le calcul du gradient instantanne ";
cout << "\n Met_abstraite::Cal_explicit_tdt(..." << endl;
Sortie(1);
}
#endif
Calcul_gradVBB_tdt(tab_noeud,dphi,nombre_noeud); // calcul du gradient de vitesse
DgradVBB_tdt(dphi); // calcul de la variation du gradient de vitesse instantannée
}
// liberation des tenseurs intermediaires
LibereTenseur();
return ex_impli;
};
// calcul de gijHH_0 et de giH_0 juste après le calcul implicite ou explicite (sinon il y a erreur)
const Met_abstraite::gijHH_0_et_giH_0& Met_abstraite::Cal_gijHH_0_et_giH_0_apres_im_expli()
{ Calcul_gijHH_0 (); // métrique en deux contravariants à t=0
Calcul_giH_0(); // base duale à t=0
return ex_gijHH_0_et_giH_0;
};
// calcul et récupération de la variation seconde de la métrique à t+dt
// total = true : indique que le calcul est complet, à partir des données de base
// c-a-d calcul de la variation de vecteur de base puis calcul de la variation seconde
// = false: le calcul est simplifié, on considère que la variation des vecteurs de base vient
// juste d'être calculé, dans un calcul implicit, on ne calcul alors que la variation seconde
const Tableau2 <TenseurBB * > & Met_abstraite::CalVar2GijBBtdt
(bool total,const Mat_pleine& dphi,int nombre_noeud,const Vecteur& phi)
{ if (total)
D_giB_tdt(dphi,nombre_noeud,phi);
// puis variation seconde
D2_gijBB_tdt();
return d2_gijBB_tdt;
};
// --------------- cas de la dynamique --------------------
// calcul pour la matrice masse
const Met_abstraite::Dynamiq& Met_abstraite::Cal_pourMatMass
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
int nombre_noeud,const Vecteur& phi)
{ Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_gijBB_0 (); // metrique base naturelle
Jacobien_0(); // jacobien initiale
// Calcul_gradVBB_moyen_t(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
// Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
// Calcul_gradVBB_moyen_tdt(tab_noeud,dphi,nombre_noeud); // gradient de vitesse moyen
// Calcul_gijBB_tdt (); // de la métrique finale
// Jacobien_tdt(); // calcul du jacobien a tdt
// liberation des tenseurs intermediaires
LibereTenseur();
return ex_Dynamiq;
};
// ========== remontee aux informations =========================
// pour la remontee au infos duaux
const Met_abstraite::InfoImp& Met_abstraite::Cal_InfoImp
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
const Vecteur& phi, int nombre_noeud)
{ Calcul_M0(tab_noeud,phi,nombre_noeud);
Calcul_Mtdt(tab_noeud,phi,nombre_noeud);
Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
Calcul_gijBB_0 (); // "
Calcul_gijHH_0 (); // composantes controvariantes
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes
// bases duales
Calcul_giH_0();
Calcul_giH_tdt();
// retour des infos
// liberation des tenseurs intermediaires
LibereTenseur();
// return ex;
return ex_InfoImp;
};
const Met_abstraite::InfoExp_t& Met_abstraite::Cal_InfoExp_t
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
const Vecteur& phi, int nombre_noeud)
{ Calcul_M0(tab_noeud,phi,nombre_noeud);
Calcul_Mt(tab_noeud,phi,nombre_noeud);
Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
Calcul_gijBB_0 (); // "
Calcul_gijHH_0 (); // composantes controvariantes
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes
// bases duales
Calcul_giH_0();
Calcul_giH_t();
// retour des infos
// liberation des tenseurs intermediaires
LibereTenseur();
// return ex;
return ex_InfoExp_t;
};
const Met_abstraite::InfoExp_tdt& Met_abstraite::Cal_InfoExp_tdt
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
const Vecteur& phi, int nombre_noeud)
{ Calcul_M0(tab_noeud,phi,nombre_noeud);
Calcul_Mtdt(tab_noeud,phi,nombre_noeud);
Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
Calcul_gijBB_0 (); // "
Calcul_gijHH_0 (); // composantes controvariantes
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes
// bases duales
Calcul_giH_0();
Calcul_giH_tdt();
// retour des infos
// liberation des tenseurs intermediaires
LibereTenseur();
return ex_InfoExp_tdt;
};
// cas sortie d'info à 0 t et tdt: point, giB, giH,
// calcul des termes de la classe Info0_t_tdt
const Met_abstraite::Info0_t_tdt& Met_abstraite::Cal_Info0_t_tdt
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi
,const Vecteur& phi, int nombre_noeud)
{ Calcul_M0(tab_noeud,phi,nombre_noeud);
Calcul_Mt(tab_noeud,phi,nombre_noeud);
Calcul_Mtdt(tab_noeud,phi,nombre_noeud);
Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a tdt
Calcul_gijBB_0 (); // "
Calcul_gijHH_0 (); // composantes controvariantes
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes
// bases duales
Calcul_giH_0();
Calcul_giH_t();
Calcul_giH_tdt();
// retour des infos
// liberation des tenseurs intermediaires
LibereTenseur();
return ex_Info0_t_tdt;
};
// cas du calcul de la déformation d'Almansi uniquement
const Met_abstraite::Pour_def_Almansi Met_abstraite::Cal_pour_def_Almansi_au_temps
(Enum_dure temps,const Tableau<Noeud *>& tab_noeud,const Mat_pleine& dphi,int nombre_noeud
,const Vecteur& phi)
{ Met_abstraite::Pour_def_Almansi pdamsi;
Calcul_giB_0(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t=0
Calcul_gijBB_0 (); // metrique base naturelle
pdamsi.gijBB_0=gijBB_0;
switch (temps)
{ case TEMPS_t:
{ // calcul des grandeurs à t
Calcul_giB_t(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
Calcul_gijBB_t (); // "
pdamsi.gijBB=gijBB_t;
break;
}
case TEMPS_tdt:
{ // calcul des grandeurs à tdt
Calcul_giB_tdt(tab_noeud,dphi,nombre_noeud,phi); // calcul de la base a t
Calcul_gijBB_tdt (); // "
pdamsi.gijBB=gijBB_tdt;
break;
}
case TEMPS_0:
{ // on ne fait rien, c'est déjà calculé
break;
}
};
return pdamsi;
};
// cas du calcul de la déformation logarithmique uniquement
const Met_abstraite::Pour_def_log Met_abstraite::Cal_pour_def_log_au_temps
(Enum_dure ,const Tableau<Noeud *>& ,const Mat_pleine&
,int ,const Vecteur& )
{cout << "\n erreur, calcul non fonctionnelle !! "
<< "\n Met_abstraite::Pour_def_log Met_abstraite::Cal_pour_def_log_au_temps(.." << endl;
Sortie(1);
// pour l'instant rien
Met_abstraite::Pour_def_log toto;
return toto;
};
// construction d'une métrique umat
// - construction d'une métrique qui dépend du paramétrage matériel = X_(0)^a
// - en fonction d'une métrique normale fonction de l'interpolation sur
// les éléments de référence c'est-à-dire theta^i
const Met_abstraite::Umat_cont& Met_abstraite::Construction_Umat(const Met_abstraite::Impli& ex)
{ // construction de la métrique umat associée qui correspond à l'opérateur gradient,
// c'est-à-dire la métrique correspondant aux coordonnées initiales considérées comme
// paramétrage matériel
// d'où dans ce cas gijBB_0 et gijHH_0 correspondent à l'identité
// a priori on est en dim=3
// *** modif février 2018: on considère aussi le cas et nb_vecteur = 2
#ifdef MISE_AU_POINT
if ((dim_base!= 3))// || (nbvec_base != 3))
{ cout << "\n erreur la dimension est different de trois"
<< " dim_base = " << dim_base //<< " nbvec_base= " << nbvec_base
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
if (nbvec_base != ex.giB_0->NbVecteur())
{ cout << "\n erreur le nombre de vecteur " << nbvec_base
<< " est different de celui de la base transmise " << ex.giB_0->NbVecteur()
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
#endif
switch (ex.giB_0->NbVecteur())
{ case 3: *gijHH_0 = IdHH3;*gijBB_0 = IdBB3; break;
case 2: *gijHH_0 = IdHH2;*gijBB_0 = IdBB2; break;
case 1: *gijHH_0 = IdHH1;*gijBB_0 = IdBB1;break;
default:
{ cout << "\n erreur pas de vecteur de base defini"
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
break;
};
// on ne les touches pas
// on doit faire un changement de base pour les autres grandeurs
// cas des vecteurs de base
ex.giB_t->ChangeBase_theta_vers_Xi(*giB_t,*(ex.giH_0));
ex.giB_tdt->ChangeBase_theta_vers_Xi(*giB_tdt,*(ex.giH_0));
ex.giH_t->ChangeBase_theta_vers_Xi(*giH_t,*(ex.giB_0));
ex.giH_tdt->ChangeBase_theta_vers_Xi(*giH_tdt,*(ex.giB_0));
// puis on complète en fonction du nombre de vecteur dans ex
// si ex en 2D -> on complète avec un vecteur normal unitaire
// si ex en 1D -> on complète avec deux vecteurs normaux unitaires
switch (ex.giB_0->NbVecteur())
{ case 1: giB_t->CoordoB(2) = giB_tdt->CoordoB(2) = giB_t->CoordoB(3) = giB_tdt->CoordoB(3)= CoordonneeB(0,0,1);
giH_t->CoordoH(2) = giH_tdt->CoordoH(2) = giH_t->CoordoH(3) = giH_tdt->CoordoH(3)= CoordonneeH(0,0,1);
break;
case 2: giB_t->CoordoB(3) = giB_tdt->CoordoB(3)= CoordonneeB(0,0,1);
giH_t->CoordoH(3) = giH_tdt->CoordoH(3)= CoordonneeH(0,0,1);
break;
case 3: *gijHH_0 = IdHH3;*gijBB_0 = IdBB3;break;
default:
{ cout << "\n erreur pas de vecteur de base defini"
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
break;
};
// cas des métriques
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes à t
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes à t
// les jacobiens
Jacobien_t(); // jacobien à t
Jacobien_tdt(); // et à tdt
return umat_cont;
};
// construction d'une métrique umat
// - construction d'une métrique qui dépend du paramétrage matériel = X_(0)^a
// - en fonction d'une métrique normale fonction de l'interpolation sur
// les éléments de référence c'est-à-dire theta^i
const Met_abstraite::Umat_cont& Met_abstraite::Construction_Umat(const Met_abstraite::Umat_cont& ex)
{ // construction de la métrique umat associée qui correspond à l'opérateur gradient,
// c'est-à-dire la métrique correspondant aux coordonnées initiales considérées comme
// paramétrage matériel
// a priori on est en dim=3
// *** modif février 2018: on considère le cas et nb_vecteur = 3
#ifdef MISE_AU_POINT
if ((dim_base!= 3))// || (nbvec_base != 3))
{ cout << "\n erreur la dimension est different de trois"
<< " dim_base = " << dim_base //<< " nbvec_base= " << nbvec_base
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
if (nbvec_base != ex.giB_0->NbVecteur())
{ cout << "\n erreur le nombre de vecteur " << nbvec_base
<< " est different de celui de la base transmise " << ex.giB_0->NbVecteur()
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
#endif
switch (ex.giB_0->NbVecteur())
{ case 3: *gijHH_0 = IdHH3;*gijBB_0 = IdBB3; break;
case 2: *gijHH_0 = IdHH2;*gijBB_0 = IdBB2; break;
case 1: *gijHH_0 = IdHH1;*gijBB_0 = IdBB1;break;
default:
{ cout << "\n erreur pas de vecteur de base defini"
<< "\n Met_abstraite::Construction_Umat(...";
Sortie(1);
};
break;
};
// on ne les touches pas
// on doit faire un changement de base pour les autres grandeurs
// cas des vecteurs de base
ex.giB_t->ChangeBase_theta_vers_Xi(*giB_t,*(ex.giH_0));
ex.giB_tdt->ChangeBase_theta_vers_Xi(*giB_tdt,*(ex.giH_0));
ex.giH_t->ChangeBase_theta_vers_Xi(*giH_t,*(ex.giB_0));
ex.giH_tdt->ChangeBase_theta_vers_Xi(*giH_tdt,*(ex.giB_0));
// // puis on complète en fonction du nombre de vecteur dans ex
// // si ex en 2D -> on complète avec un vecteur normal unitaire
// // si ex en 1D -> on complète avec deux vecteurs normaux unitaires
//
// switch (ex.giB_0->NbVecteur())
// { case 1: giB_t->CoordoB(2) = giB_tdt->CoordoB(2) = giB_t->CoordoB(3) = giB_tdt->CoordoB(3)= CoordonneeB(0,0,1);
// giH_t->CoordoH(2) = giH_tdt->CoordoH(2) = giH_t->CoordoH(3) = giH_tdt->CoordoH(3)= CoordonneeH(0,0,1);
// break;
// case 2: giB_t->CoordoB(3) = giB_tdt->CoordoB(3)= CoordonneeB(0,0,1);
// giH_t->CoordoH(3) = giH_tdt->CoordoH(3)= CoordonneeH(0,0,1);
// break;
// case 3: *gijHH_0 = IdHH3;*gijBB_0 = IdBB3;break;
// default:
// { cout << "\n erreur pas de vecteur de base defini"
// << "\n Met_abstraite::Construction_Umat(...";
// Sortie(1);
// };
// break;
// };
// cas des métriques
// (ex.gijBB_tdt)->BaseAbsolue(*gijBB_tdt,*(ex.giH_0));
// (ex.gijHH_tdt)->BaseAbsolue(*gijHH_tdt,*(ex.giB_0));
// ex.gijBB_t->BaseAbsolue(*gijBB_t,*(ex.giH_0));
// ex.gijHH_t->BaseAbsolue(*gijHH_t,*(ex.giB_0));
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes à t
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes à t
// les jacobiens
Jacobien_t(); // jacobien à t
Jacobien_tdt(); // et à tdt
return umat_cont;
};
// ========== utilise par le contact =========================
// calcul d'un point M0 en fonction de phi et des coordonnees a 0
const Coordonnee & Met_abstraite::PointM_0 // ( stockage a t=0)
( const Tableau<Noeud *>& tab_noeud, const Vecteur& Phi)
{ Calcul_M0(tab_noeud,Phi,nomb_noeud);
return *M0;
};
// calcul d'un point M en fonction de phi et des coordonnees a t
const Coordonnee & Met_abstraite::PointM_t // ( stockage a t)
( const Tableau<Noeud *>& tab_noeud, const Vecteur& Phi)
{ Calcul_Mt(tab_noeud,Phi,nomb_noeud);
return *Mt;
};
// calcul de la variation d'un point M par rapport aux ddl ,
// en fonction de phi et des coordonnees a t
const Tableau<Coordonnee> & Met_abstraite::D_PointM_t // ( stockage a t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
{ Calcul_d_Mt(tab_noeud,Phi,nomb_noeud);
return *d_Mt;
};
// calcul d'un point M en fonction de phi et des coordonnees a tdt
const Coordonnee & Met_abstraite::PointM_tdt // ( stockage a tdt)
( const Tableau<Noeud *>& tab_noeud, const Vecteur& Phi)
{ Calcul_Mtdt(tab_noeud,Phi,nomb_noeud);
return *Mtdt;
};
// calcul de la variation d'un point M par rapport aux ddl ,
// en fonction de phi et des coordonnees a tdt
const Tableau<Coordonnee> & Met_abstraite::D_PointM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
{ Calcul_d_Mtdt(tab_noeud,Phi,nomb_noeud);
return *d_Mtdt;
};
// calcul de la vitesse du point M en fonction de phi et des coordonnees a 0
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t
const Coordonnee & Met_abstraite::VitesseM_0 // ( stockage a t=0)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
{ if (tab_noeud(1)->Existe_ici(V1))
{ Calcul_V0(tab_noeud,Phi,nomb_noeud); }
else
{ Calcul_V_moy0(tab_noeud,Phi,nomb_noeud); };
return *V0;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::VitesseM_0(const Noeud* noeud)
{ if (noeud->Existe_ici(V1)) { Calcul_V0(noeud); }
else { Calcul_V_moy0(noeud); };
return *V0;
};
// calcul de la vitesse du point M en fonction de phi et des coordonnees a t
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t
const Coordonnee & Met_abstraite::VitesseM_t // ( stockage a t=t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
{ if (tab_noeud(1)->Existe_ici(V1))
{ Calcul_Vt(tab_noeud,Phi,nomb_noeud); }
else
{ Calcul_V_moyt(tab_noeud,Phi,nomb_noeud); };
return *Vt;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::VitesseM_t(const Noeud* noeud)
{ if (noeud->Existe_ici(V1)) { Calcul_Vt(noeud); }
else { Calcul_V_moyt(noeud); };
return *Vt;
};
// calcul de la variation de la vitesse du point M par rapport aux ddl ,
// en fonction de phi et des coordonnees a t
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t
// ddl_vitesse : indique si oui ou non il s'agit de variation par rapport
// aux ddl de vitesse ou au ddl de position
const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_t // ( stockage a t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi,bool ddl_vitesse)
{ if (tab_noeud(1)->Existe_ici(V1))
{ Calcul_d_Vt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = true;}
else
{ Calcul_d_V_moyt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = false;};
return *d_Vt;
};
// idem mais au noeud passé en paramètre
const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_t(const Noeud* noeud,bool ddl_vitesse)
{ if (noeud->Existe_ici(V1)) { Calcul_d_Vt(noeud); ddl_vitesse = true;}
else { Calcul_d_V_moyt(noeud); ddl_vitesse = false; };
return *d_Vt;
};
// calcul de la vitesse du point M en fonction de phi et des coordonnees a tdt
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t
const Coordonnee & Met_abstraite::VitesseM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi)
{ if (tab_noeud(1)->Existe_ici(V1))
{ Calcul_Vtdt(tab_noeud,Phi,nomb_noeud); }
else
{ Calcul_V_moytdt(tab_noeud,Phi,nomb_noeud);};
return *Vtdt;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::VitesseM_tdt(const Noeud* noeud)
{ if (noeud->Existe_ici(V1)) { Calcul_Vtdt(noeud); }
else { Calcul_V_moytdt(noeud); };
return *Vtdt;
};
// calcul de la variation de la vitesse du point M par rapport aux ddl ,
// en fonction de phi et des coordonnees a tdt
// dans le cas où les ddl de vitesse existent, ils sont directement interpolés
// dans le cas où ils n'existent pas, on utilise les vitesses moyennes : delta M / delta t
// ddl_vitesse : indique si oui ou non il s'agit de variation par rapport
// aux ddl de vitesse ou au ddl de position
const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& Phi,bool ddl_vitesse)
{ if (tab_noeud(1)->Existe_ici(V1))
{ Calcul_d_Vtdt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = true;}
else
{ Calcul_d_V_moytdt(tab_noeud,Phi,nomb_noeud); ddl_vitesse = false; };
return *d_Vtdt;
};
// idem mais au noeud passé en paramètre
const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_tdt(const Noeud* noeud,bool ddl_vitesse)
{ if (noeud->Existe_ici(V1)) { Calcul_d_Vtdt(noeud); ddl_vitesse = true;}
else { Calcul_d_V_moytdt(noeud); ddl_vitesse = false; };
return *d_Vtdt;
};
// calcul de l'accélération du point M en fonction de phi et des coordonnees a 0
// dans le cas où les ddl d'accélération existent, ils sont directement interpolés
// sinon erreur
const Coordonnee & Met_abstraite::AccelerationM_0 // ( stockage a t=0)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gamma0(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_0(..." ;
Sortie(1);
};
return *gamma0;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_0 (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gamma0(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_0(..." ;
Sortie(1);
};
return *gamma0;
};
// idem à t
const Coordonnee & Met_abstraite::AccelerationM_t // ( stockage a t=t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gammat(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_t(..." ;
Sortie(1);
};
return *gammat;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_t (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gammat(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_t(..." ;
Sortie(1);
};
return *gammat;
};
// idem à tdt
const Coordonnee & Met_abstraite::AccelerationM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gammatdt(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_tdt(..." ;
Sortie(1);
};
return *gammatdt;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_tdt (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gammatdt(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_tdt(..." ;
Sortie(1);
};
return *gammatdt;
};
// calcul de la base naturel ( stockage a t=0) au point correspondant au dphi
const BaseB& Met_abstraite::BaseNat_0 // en fonction des coordonnees a t=0
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
{ Calcul_giB_0 (tab_noeud,dphi,nomb_noeud,phi);
return *giB_0;
};
// calcul de la base naturel ( stockage a t) au point correspondant au dphi
const BaseB& Met_abstraite::BaseNat_t // en fonction des coordonnees a t
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
{ Calcul_giB_t (tab_noeud,dphi,nomb_noeud,phi);
return *giB_t;
};
// calcul de la base naturel ( stockage a t=tdt) au point correspondant au dphi
const BaseB& Met_abstraite::BaseNat_tdt // en fonction des coordonnees a tdt
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)
{ Calcul_giB_tdt (tab_noeud,dphi,nomb_noeud,phi);
return *giB_tdt;
};
// calcul de la variation de la base naturel, au point correspondant au dphi en fonction des coord a tdt
// nécessite que la base naturelle ait été calculée auparavant
const Tableau <BaseB>& Met_abstraite::d_BaseNat_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Mat_pleine& dphi,const Vecteur& phi)
{ D_giB_tdt(dphi,tab_noeud.Taille(),phi); //
return *d_giB_tdt;
};
// calcul de la base naturelle et duale ( stockage a t=0) en fonction des coord a 0
void Met_abstraite::BaseND_0( const Tableau<Noeud *>& tab_noeud,const Mat_pleine& dphi,
const Vecteur& phi,BaseB& bB,BaseH& bH)
{ Calcul_giB_0 (tab_noeud,dphi,nomb_noeud,phi);
Calcul_gijBB_0 (); // "
Calcul_gijHH_0 (); // composantes controvariantes
Calcul_giH_0 ();
bB = *giB_0;
bH = *giH_0;
};
// calcul de la base naturelle et duale ( stockage a t) en fonction des coord a t
void Met_abstraite::BaseND_t( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
const Vecteur& phi,BaseB& bB,BaseH& bH)
{ Calcul_giB_t (tab_noeud,dphi,nomb_noeud,phi);
Calcul_gijBB_t (); // "
Calcul_gijHH_t (); // composantes controvariantes
Calcul_giH_t ();
bB = *giB_t;
bH = *giH_t;
};
// calcul de la base naturelle et duale ( stockage a tdt) en fonction des coord a tdt
void Met_abstraite::BaseND_tdt( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,
const Vecteur& phi,BaseB& bB,BaseH& bH)
{ Calcul_giB_tdt (tab_noeud,dphi,nomb_noeud,phi);
Calcul_gijBB_tdt (); // "
Calcul_gijHH_tdt (); // composantes controvariantes
Calcul_giH_tdt ();
bB = *giB_tdt;
bH = *giH_tdt;
};
// ====== informations diverses (mais cohérentes, c-a-d, peuvent être appelées directement sans init) ====
double Met_abstraite::JacobienInitial(const Tableau<Noeud *>& tab_noeud,const Mat_pleine& tabDphi
,int nombre_noeud,const Vecteur& phi)
{ Calcul_giB_0(tab_noeud,tabDphi,nombre_noeud,phi); // calcul de la base a t=0
Jacobien_0(); // calcul du jacobien
return jacobien_0; // retour
};