rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Elements/Mecanique/SFE/DeformationSfe1.cc
Gérard Rio 9692dbd130 intégration du répertoire Mecanique: 
- contient les éléments finis, métriques associées, déformations ...
intégration du réperoire Géométrie:
- contient les géométries 1D 2D et 3D, les frontières des éléments géométriques
2021-09-27 12:42:13 +02:00

1041 lines
48 KiB
C++
Raw Blame History

// 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-2021 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 "DeformationSfe1.h"
# include "Met_Sfe1.h"
#include "ConstMath.h"
#include "ParaGlob.h"
#include "Util.h"
// -------------------------- variables static -------------------
//int DeformationSfe1::numInteg_total = 0;
// indicateur utilisé par VerifCal_def et VerifCal_implicit
int DeformationSfe1::indic_VerifCal_implicitSfe1 = 0;
// ---------- constructeur----------------------------------------
DeformationSfe1::DeformationSfe1 () // constructeur ne devant pas etre utilise
{
#ifdef MISE_AU_POINT
{ cout << "\nErreur : le constructeur par defaut ne doit pa etre utilise !\n";
cout << "DeformationSfe1::DeformationSfe1 () \n";
Sortie(1);
};
#endif
};
// constructeur normal dans le cas d'un ou de plusieurs pt d'integration
DeformationSfe1::DeformationSfe1 (Met_abstraite & a,Tableau<Noeud *>& tabnoeud
,Tableau <Mat_pleine> const & tDphS,Tableau <Vecteur> const & tPhS
,Tableau <Mat_pleine> const & tDphH,Tableau <Vecteur> const & tPhH
):
Deformation (a,tabnoeud,tDphS,tPhS )
,epais(NULL),tabTypeCL(NULL),vplan(NULL)
,numInteg_ep(0),numInteg_surf(0),sauve_numInteg_ep(0),sauve_numInteg_surf(0)
{ tabDphiH = &(tDphH);
tabPhiH = &(tPhH);
// on regarde s'il s'agit de 2D ou 3D c-a-d s'il faut stocker une épaisseur ou non
if (a.Nbvec_des_bases() == 2)
epais = new Epai();
};
// constructeur de copie
DeformationSfe1::DeformationSfe1 (const DeformationSfe1& a) :
Deformation(a)
,epais(NULL)
,tabTypeCL(a.tabTypeCL),vplan(a.vplan)
,numInteg_ep(a.numInteg_ep),numInteg_surf(a.numInteg_surf)
,sauve_numInteg_ep(a.sauve_numInteg_ep),sauve_numInteg_surf(a.sauve_numInteg_surf)
{ tabDphiH = a.tabDphiH;
tabPhiH = a.tabPhiH;
// on regarde s'il s'agit de 2D ou 3D c-a-d s'il faut stocker une épaisseur ou non
if (a.epais != NULL)
epais = new Epai(*(a.epais));
};
DeformationSfe1::~DeformationSfe1 ()
{ if (epais != NULL) delete epais;};
// ============ METHODES PUBLIQUES : ==================
// change le numero d'integration courant
void DeformationSfe1::ChangeNumInteg(int ni)
{ int nbptSur = tabPhi->Taille();
int nbptEpa = tabPhiH->Taille();
sauve_numInteg_surf=numInteg_surf;
sauve_numInteg_ep = numInteg_ep;
sauve_numInteg = numInteg;
numInteg_surf = (ni-1) / nbptEpa +1; // division entière
numInteg_ep = ni - (numInteg_surf-1) * nbptEpa ;
// numInteg_total = ni;
} ;
// change les numeros d'integration de surface et d'epaisseur courant
void DeformationSfe1::ChangeNumIntegSfe1
(int nisurf, int niepaiss)
{ sauve_numInteg_surf=numInteg_surf;
sauve_numInteg_ep = numInteg_ep;
sauve_numInteg = numInteg;
numInteg_ep = niepaiss; numInteg = numInteg_surf = nisurf;
// on fait les changements dus aux nouveaux pts integ
// numInteg_total = (tabPhiH->Taille()) * (numInteg_surf-1) + numInteg_ep;
} ;
// affichage des informations
void DeformationSfe1::Affiche() const
{ cout << "\n -- deformation SFE : --- "
<< "\n nb noeud concerne = "<< tabnoeud->Taille()
<< " numInteg_surf= "<< numInteg_surf
<< " numInteg_ep= "<< numInteg_ep;
if (tabnoeud != NULL)
{cout << "\n -- information concernant les noeuds: \n";
for (int i = 1;i<= tabnoeud->Taille();i++)
(*tabnoeud)(i)->Affiche();
};
if (metrique != NULL)
{cout << "\n -- information concernant la metrique actuelle au pti --";
metrique->Affiche();
};
cout << flush;
};
// calcul explicit:tous les parametres sont de resultats cas d'un calcul à t
const Met_abstraite::Expli& DeformationSfe1::Cal_explicit_t
( const Tableau <double>& def_equi_t,TenseurBB & epsBB_t,Tableau <TenseurBB *> & d_epsBB
,Tableau <double>& def_equi,TenseurBB& DepsBB,TenseurBB& delta_epsBB,bool premier_calcul)
{bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
bool pas_de_gradV=false; // indique que l'on veut a priori le calcul du gradient de vitesse
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Expli* ex; // le retour
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
ex = &(met_Sfe1->CalSfe1_explicit_t(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
ex = &(met_Sfe1->CalSfe1_explicit_simple_t(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
// ici il y a le choix entre les différents types de calcul de la déformation (Almansi, Green-Lagrange ..
switch (type_deformation)
{ case DEFORMATION_STANDART :
{Cal_explicit_Almansi
(gradV_instantane,epsBB_t,d_epsBB,DepsBB,delta_epsBB,premier_calcul,*ex);
break;
}
case DEFORMATION_LOGARITHMIQUE:
{Cal_explicit_Logarithmique
(gradV_instantane,epsBB_t,d_epsBB,DepsBB,delta_epsBB,premier_calcul,*ex);
break;
}
// case DEFORMATION_CUMU_LOGARITHMIQUE : case DEF_CUMUL_CORROTATIONNEL : case DEF_CUMUL_ROTATION_PROPRE :
// {Cal_explicit_def_cumule
// (gradV_instantane,epsBB_t,d_epsBB,DepsBB,delta_epsBB,premier_calcul,*ex);
// break;
// }
default :
cout << "\nErreur : type de deformation ( " << Nom_type_deformation(type_deformation)
<< " ) non traite !\n";
cout << "Deformation::Cal_explicit(... \n";
Sortie(1);
};
// sauvegarde des infos à 0 éventuellement
//$$$$$$$$$$$$ en fait je crois bien que ça ne sert à rien de sauvegarder le saveDefResul du sfe,
// car le seul qui est utiliser dans Almansi par exemple, c'est le général, donc relatif aux gi (et non au ai),
// celui qui est spécifique au cas SFE contient en plus les infos de la facette, mais qui ne servent pas donc
// alourdisses le stockage !!!!
// --- on calcul la déformation cumulée
TenseurBH * delta_epsBH = NevezTenseurBH(delta_epsBB.Dimension(), 0.);
{*delta_epsBH = delta_epsBB * (*(ex->gijHH_t));
double delta_eps_equi = sqrt(2./3. * ( ((*delta_epsBH) && (*delta_epsBH)) - Sqr(delta_epsBH->Trace()) /3. ));
def_equi(1) = def_equi_t(1) + delta_eps_equi;
def_equi(4) = delta_eps_equi;
delete delta_epsBH;
};
{TenseurBH * epsBH = NevezTenseurBH(epsBB_t.Dimension(), 0.);
*epsBH = epsBB_t * (*(ex->gijHH_t));
def_equi(2) = sqrt(2./3. * ( ((*epsBH) && (*epsBH)) - Sqr(epsBH->Trace()) /3. ));
delete epsBH;
if (def_equi(2) > def_equi_t(3))
def_equi(3) = def_equi(2);
};
if (premier_calcul) saveDefResul->MiseAJourGrandeurs_a_0(metrique);
return *ex;
};
// calcul explicit:tous les parametres sont de resultats cas d'un calcul à tdt
const Met_abstraite::Expli_t_tdt& DeformationSfe1::Cal_explicit_tdt
( const Tableau <double>& def_equi_t,TenseurBB & epsBB_tdt,Tableau <TenseurBB *> & d_epsBB
,Tableau <double>& def_equi,TenseurBB& DepsBB,TenseurBB& delta_epsBB_tdt,bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Expli_t_tdt* ex; // le retour
// appel de la metrique
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
ex = &(met_Sfe1->CalSfe1_explicit_tdt(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
ex = &(met_Sfe1->CalSfe1_explicit_simple_tdt(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
// ici il y a le choix entre les différents types de calcul de la déformation (Almansi, Green-Lagrange ..
switch (type_deformation)
{ case DEFORMATION_STANDART :
{Cal_explicit_Almansi_tdt
(gradV_instantane,epsBB_tdt,d_epsBB,DepsBB,delta_epsBB_tdt,premier_calcul,*ex);
break;
}
case DEFORMATION_LOGARITHMIQUE:
{Cal_explicit_logarithmique_tdt
(gradV_instantane,epsBB_tdt,d_epsBB,DepsBB,delta_epsBB_tdt,premier_calcul,*ex);
break;
}
// case DEFORMATION_CUMU_LOGARITHMIQUE : case DEF_CUMUL_CORROTATIONNEL : case DEF_CUMUL_ROTATION_PROPRE :
// {Cal_explicit_def_cumule_tdt
// (gradV_instantane,epsBB_tdt,d_epsBB,DepsBB,delta_epsBB_tdt,premier_calcul,*ex);
// break;
// }
default :
cout << "\nErreur : type de deformation ( " << Nom_type_deformation(type_deformation)
<< " ) non traite !\n";
cout << "Deformation::Cal_explicit_tdt(... \n";
Sortie(1);
};
// sauvegarde des infos à 0 éventuellement
if (premier_calcul) saveDefResul->MiseAJourGrandeurs_a_0(metrique);
// sauvegarde des infos à t à chaque passage
saveDefResul->MiseAJourGrandeurs_a_tdt(metrique,DepsBB);
// --- on calcul la déformation cumulée
{TenseurBH * delta_epsBH = NevezTenseurBH(delta_epsBB_tdt.Dimension(), 0.);
*delta_epsBH = delta_epsBB_tdt * (*(ex->gijHH_tdt));
double delta_eps_equi = sqrt(2./3. * ( ((*delta_epsBH) && (*delta_epsBH)) - Sqr(delta_epsBH->Trace()) /3. ));
def_equi(1) = def_equi_t(1) + delta_eps_equi;
def_equi(4) = delta_eps_equi;
delete delta_epsBH;
};
{TenseurBH * epsBH = NevezTenseurBH(epsBB_tdt.Dimension(), 0.);
*epsBH = epsBB_tdt * (*(ex->gijHH_tdt));
def_equi(2) = sqrt(2./3. * ( ((*epsBH) && (*epsBH)) - Sqr(epsBH->Trace()) /3. ));
delete epsBH;
if (def_equi(2) > def_equi_t(3))
def_equi(3) = def_equi(2);
};
return *ex;
};
// cas implicite : tous les parametres sont de resultats
const Met_abstraite::Impli& DeformationSfe1::Cal_implicit
( const Tableau <double>& def_equi_t,TenseurBB & epsBB_tdt,Tableau <TenseurBB *> & d_epsBB_tdt
,Tableau <double>& def_equi,TenseurBB& DepsBB,TenseurBB& delta_epsBB,bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Impli* ex; // la sortie
// toutes les variables de passage a metrique apres l'appel
// pointeront sur des variables deja dimensionnees
// pour les Tableau <> il y a dimensionnement auto a l'affectation
// appel de la metrique
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
// dans le cas du premier calcul il y a calcul des grandeurs à 0 et à t, pas dans les autres cas
ex =&(met_Sfe1->CalSfe1_implicit ( *tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
// dans ce cas ci, les infos relatives à la facette, à la courbure, sont issue du calcul du premier pt d'integ
// il n'y a pas de sauvegarde particulière, simplement, on considère que les infos n'ont pas été écrasées entre temps
ex =&(met_Sfe1->CalSfe1_implicit_simple ( *tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
// ici il y a le choix entre les différents types de calcul de la déformation (Almansi, Green-Lagrange ..
switch (type_deformation)
{ case DEFORMATION_STANDART :
{
Cal_implicit_Almansi
(gradV_instantane,epsBB_tdt,d_epsBB_tdt,DepsBB,delta_epsBB,premier_calcul,*ex);
break;
}
case DEFORMATION_LOGARITHMIQUE:
{Cal_implicit_Logarithmique
(gradV_instantane,epsBB_tdt,d_epsBB_tdt,DepsBB,delta_epsBB,premier_calcul,*ex);
break;
}
case DEFORMATION_CUMU_LOGARITHMIQUE : case DEF_CUMUL_CORROTATIONNEL : case DEF_CUMUL_ROTATION_PROPRE :
{Cal_implicit_def_cumule
(gradV_instantane,epsBB_tdt,d_epsBB_tdt,DepsBB,delta_epsBB,premier_calcul,*ex);
break;
}
default :
cout << "\nErreur : type de deformation ( " << Nom_type_deformation(type_deformation)
<< " ) non traite !\n";
cout << "Deformation::Cal_implicit(... \n";
Sortie(1);
};
//............... debug vérification ...................
// // vérification éventuelle
// VerifCal_implicit(gradV_instantane, *ex);
//............... debug vérification ...................
// --- on calcul la déformation cumulée
{TenseurBH * delta_epsBH = NevezTenseurBH(epsBB_tdt.Dimension(), 0.);
*delta_epsBH = delta_epsBB * (*(ex->gijHH_tdt));
double delta_eps_equi = sqrt(2./3. * ( ((*delta_epsBH) && (*delta_epsBH)) - Sqr(delta_epsBH->Trace()) /3. ));
def_equi(1) = def_equi_t(1) + delta_eps_equi;
def_equi(4) = delta_eps_equi;
delete delta_epsBH;
};
{TenseurBH * epsBH = NevezTenseurBH(epsBB_tdt.Dimension(), 0.);
*epsBH = epsBB_tdt * (*(ex->gijHH_tdt));
def_equi(2) = sqrt(2./3. * ( ((*epsBH) && (*epsBH)) - Sqr(epsBH->Trace()) /3. ));
delete epsBH;
if (def_equi(2) > def_equi_t(3))
def_equi(3) = def_equi(2);
};
// sauvegarde des infos à 0 éventuellement:
if (premier_calcul) saveDefResul->MiseAJourGrandeurs_a_0(metrique);
// sauvegarde des infos à tdt à chaque passage
saveDefResul->MiseAJourGrandeurs_a_tdt(metrique,DepsBB);
// *** pour supprimer les warnings à la compilation *** mais on ne doit jamais passer ici
// const Met_abstraite::Impli& toto = * (new Met_abstraite::Impli()); return toto;
return *ex;
};
// ---------------- calcul des variables primaires autre que pour la mécanique --------
// ------------ donc pas de retour relatif aux déformations
// calcul explicit à t :tous les parametres sont de resultats
const Met_abstraite::Expli& DeformationSfe1::Cal_explicit_t(bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Expli* ex; // le retour
// appel de la metrique
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
ex = &(met_Sfe1->CalSfe1_explicit_t(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
ex = &(met_Sfe1->CalSfe1_explicit_simple_t(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
return *ex;
};
// calcul explicit à tdt :tous les parametres sont de resultats
const Met_abstraite::Expli_t_tdt& DeformationSfe1::Cal_explicit_tdt(bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Expli_t_tdt* ex; // le retour
// appel de la metrique
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
ex = &(met_Sfe1->CalSfe1_explicit_tdt(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
ex = &(met_Sfe1->CalSfe1_explicit_simple_tdt(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
return *ex;
};
// cas implicite : tous les parametres sont de resultats
const Met_abstraite::Impli& DeformationSfe1::Cal_implicit(bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
const Met_abstraite::Impli* ex; // la sortie
// toutes les variables de passage a metrique apres l'appel
// pointeront sur des variables deja dimensionnees
// pour les Tableau <> il y a dimensionnement auto a l'affectation
// appel de la metrique
// on effectue un calcul simplifié si ce n'est pas un premier calcul et si ce n'est pas le premier ptinteg
if ((numInteg_ep == 1)||(premier_calcul)) // cas ou l'on doit calculer tous les elements de la facette
ex = &(met_Sfe1->CalSfe1_implicit (*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan));
else // cas d'un calcul simplifie
ex = &(met_Sfe1->CalSfe1_implicit_simple (*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais));
return *ex;
};
// ========== remontee aux informations =========================
// cas sortie d'un calcul implicit
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
const Met_abstraite::InfoImp DeformationSfe1::RemontImp(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoImp ex = met_Sfe1->CalSfe1_InfoImp( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_tdt);
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin);
return ex;
};
// cas sortie d'un calcul implicit
// sans calcul de matrices de passage
const Met_abstraite::InfoImp DeformationSfe1::RemontImp()
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoImp ex = met_Sfe1->CalSfe1_InfoImp( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_tdt);
return ex;
};
// cas sortie d'un calcul explicit à t
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
const Met_abstraite::InfoExp_t DeformationSfe1::RemontExp_t(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoExp_t ex = met_Sfe1->CalSfe1_InfoExp_t( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_t);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_t);
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin);
return ex;
};
// cas sortie d'un calcul explicit à t
// sans calcul de matrice de passage
const Met_abstraite::InfoExp_t DeformationSfe1::RemontExp_t()
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoExp_t ex = met_Sfe1->CalSfe1_InfoExp_t( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_t);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_t);
return ex;
};
// cas sortie d'un calcul explicit à tdt
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
const Met_abstraite::InfoExp_tdt DeformationSfe1::RemontExp_tdt(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoExp_tdt ex = met_Sfe1->CalSfe1_InfoExp_tdt( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_tdt);
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin);
return ex;
};
// cas sortie d'un calcul explicit à tdt
// sans calcul de matrice de passage
const Met_abstraite::InfoExp_tdt DeformationSfe1::RemontExp_tdt()
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::InfoExp_tdt ex = met_Sfe1->CalSfe1_InfoExp_tdt( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giB = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giH = *(ex.giH_tdt);
return ex;
};
// cas sortie d'un calcul à 0, t et tdt
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
const Met_abstraite::Info0_t_tdt DeformationSfe1::Remont0_t_tdt(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aat,Mat_pleine& Aatdt)
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::Info0_t_tdt ex = met_Sfe1->CalSfe1_Info0_t_tdt( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giBt = *(ex.giB_t);
BaseB & giBtdt = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giHt = *(ex.giH_t);
BaseH & giHtdt = *(ex.giH_tdt);
BasePassage(absolue,giB0,giBt,giBtdt,giH0,giHt,giHtdt,Aa0,Aat,Aatdt);
return ex;
};
// cas sortie d'un calcul à 0, t et tdt
// sans calcul de matrice de passage
const Met_abstraite::Info0_t_tdt DeformationSfe1::Remont0_t_tdt()
{ // recup d'un pointeur sur la metrique sfe1
Met_Sfe1* met_Sfe1 = (Met_Sfe1*) metrique;
Met_abstraite::Info0_t_tdt ex = met_Sfe1->CalSfe1_Info0_t_tdt( *tabnoeud,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
// determination des matrices de transformation de base
BaseB & giB0 = *(ex.giB_0);
BaseB & giBt = *(ex.giB_t);
BaseB & giBtdt = *(ex.giB_tdt);
BaseH & giH0 = *(ex.giH_0);
BaseH & giHt = *(ex.giH_t);
BaseH & giHtdt = *(ex.giH_tdt);
return ex;
};
// gestion du parcours de tous les points d'integration
void DeformationSfe1::PremierPtInteg()
{ sauve_numInteg_surf=numInteg_surf;
sauve_numInteg_ep = numInteg_ep;
sauve_numInteg = numInteg;
numInteg = 1 ; numInteg_ep = 1; numInteg_surf = 1;
};
bool DeformationSfe1::DernierPtInteg()
{ sauve_numInteg_surf=numInteg_surf;
sauve_numInteg_ep = numInteg_ep;
sauve_numInteg = numInteg;
// on ne contrôle que le numéro de surface vue le fonctionnement de NevezPtInteg
if (numInteg_surf <= (tabPhi->Taille()) )
return true;
else
return false;
};
void DeformationSfe1::NevezPtInteg()
{ sauve_numInteg_surf=numInteg_surf;
sauve_numInteg_ep = numInteg_ep;
sauve_numInteg = numInteg;
// les pt varient d'abord en épaisseurs pour ensuite en surface, ce qui permet d'optimiser
// le calcul de la courbure qui n'est fait que pour le premier pt d'épaisseur
if (numInteg_ep < Nb_pt_int_epai())
numInteg_ep++;
else
{ numInteg_surf++;numInteg++;
numInteg_ep = 1;
}
};
// méthode pour revenir au pti précédant
void DeformationSfe1::Retour_pti_precedant()
{numInteg=sauve_numInteg;
numInteg_surf = sauve_numInteg_surf;
numInteg_ep = sauve_numInteg_ep;
};
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
// si absolue = true: on fait un passage vers la base absolue
// si = false : on fait un passage vers une base ad hoc
void DeformationSfe1::BasePassage
(bool absolue,const BaseB & giB0,const BaseB & giB,const BaseH & giH0,const BaseH & giH,
Mat_pleine& Aa0,Mat_pleine& Aafin)
{
// *********$ sans doute à faire évoluer : (16 sept 2019) vers les cas généraux de Deformation
// car 1) c'est compliquer, et 2) je pense qu'il y a des cas qui manquent ici et donc que cela
// va -> des erreurs en sortie
// **** donc à voir si pb à venir
// determination des matrices de transformation de base
// l'objectif est de determiner un repere pertinant
// choix : un repere qui appartiend a la facette, obtenu apres projection
// du repere global
//------ cas de la config initiale, on regarde si la projection de I1 n'est pas trop petite
// def de la normale a la facette
Coordonnee N = (Util::ProdVec_coorBN(giB0(1),giB0(2))).Normer();
Coordonnee ve(0.,-N(3),N(2)); // = ProdVec(N,I1)
double norve = ve.Norme();
int tail_Aa0 = Aa0.Nb_ligne(); // pour tenir compte d'une dim = 2 ou 3
Tableau <Coordonnee> vi(tail_Aa0); // les vecteurs plans orthonormes de la facette
if (norve >= 0.01)
{ vi(2) = ve.Normer();
vi(1) = Util::ProdVec_coor(vi(2),N);
}
else
{ ve.Change_Coordonnee(3,N(3),0.,-N(1)); // = ProdVec(I2,N)
vi(1) = ve.Normer();
vi(2) = Util::ProdVec_coor(N,vi(1));
};
if (tail_Aa0 == 3)
vi(3) = N;
if(giH0.NbVecteur()==tail_Aa0)
{for (int al=1 ;al<=tail_Aa0;al++)
for (int bl = 1;bl<=tail_Aa0;bl++)
Aa0(bl,al) = giH0.Coordo(bl) * vi(al) ;
}
else // sinon cela signifie que le nombre est < donc à 3, car on traîte de repère pour facette
{for (int al=1 ;al<=tail_Aa0;al++)
{for (int bl = 1;bl<=2;bl++)
Aa0(bl,al) = giH0.Coordo(bl) * vi(al) ;
Aa0(3,al) = N * vi(al) ; // on considère que le 3ième vecteur c'est la normale
};
};
// for (int al=1 ;al<=2;al++)
// {Aa0(1,al) = giH0.Coordo(1) * vi(al) ;
// Aa0(2,al) = giH0.Coordo(2) * vi(al) ;
// }
// ---- vérification que le déterminant n'est pas nul
//{double det = Aa0(1,1) * Aa0(2,2) - Aa0(1,2) * Aa0(2,1);
// if (Abs(det) < 0.00001)
// cout << "\n erreur det0 null " << det << " dans DeformationSfe1::BasePassage( ";
//};
// ---- fin vérification
//------ cas de la config finale,
N = (Util::ProdVec_coorBN(giB(1),giB(2))).Normer();
ve.Change_Coordonnee(3,0.,-N(3),N(2)); // = ProdVec(N,I1)
norve = ve.Norme();
int tail_Aa = Aafin.Nb_ligne(); // pour tenir compte d'une dim = 2 ou 3
Tableau <Coordonnee> Aa(tail_Aa);
if (norve >= 0.01)
{ Aa(2) = ve.Normer();
Aa(1) = Util::ProdVec_coor(Aa(2),N);
}
else
{ ve.Change_Coordonnee(3,N(3),0.,-N(1)); // = ProdVec(I2,N)
Aa(1) = ve.Normer();
Aa(2) = Util::ProdVec_coor(N,Aa(1));
};
if (tail_Aa == 3)
Aa(3) = N;
if(giH.NbVecteur()==tail_Aa)
{for (int be=1 ;be<=tail_Aa;be++)
for (int bl = 1;bl<=tail_Aa;bl++)
Aafin(bl,be) = giH.Coordo(bl) * Aa(be) ;
}
else // sinon cela signifie que le nombre est < donc à 3, car on traîte de repère pour facette
{for (int be=1 ;be<=tail_Aa;be++)
{for (int bl = 1;bl<=2;bl++)
Aafin(bl,be) = giH.Coordo(bl) * Aa(be) ;
Aafin(3,be) = N * Aa(be) ; // on considère que le 3ième vecteur c'est la normale
};
};
// for (int be=1;be<=2;be++)
// { Aafin(1,be) = giH.Coordo(1) * Aa(be);
// Aafin(2,be) = giH.Coordo(2) * Aa(be);
// };
// ---- vérification que le déterminant n'est pas nul
//{double det = Aafin(1,1) * Aafin(2,2) - Aafin(1,2) * Aafin(2,1);
// if (Abs(det) < 0.00001)
// cout << "\n erreur det null " << det << " dans DeformationSfe1::BasePassage( ";
//};
// ---- fin vérification
return;
};
// cas où l'on veut les matrices de passages à 0 t et tdt
// Aa(i,a) = Aa^i_{.a}, avec g^i = Aa^i_{.a} * I^a
// tout ce passe comme si I^a est la nouvelle base vers laquelle on veut évoluer
void DeformationSfe1::BasePassage(bool absolue,const BaseB & giB0,const BaseB & giB_t,const BaseB & giB_tdt
,const BaseH & giH0,const BaseH & giH_t,const BaseH & giH_tdt
,Mat_pleine& Aa0,Mat_pleine& Aa_t,Mat_pleine& Aa_tdt)
{
// *********$ sans doute à faire évoluer : (16 sept 2019) vers les cas généraux de Deformation
// car 1) c'est compliquer, et 2) je pense qu'il y a des cas qui manquent ici et donc que cela
// va -> des erreurs en sortie
// **** donc à voir si pb à venir
// determination des matrices de transformation de base
// l'objectif est de determiner un repere pertinant
// choix : un repere qui appartiend a la facette, obtenu apres projection
// du repere global
//------ cas de la config initiale, on regarde si la projection de I1 n'est pas trop petite
// def de la normale a la facette
Coordonnee N = (Util::ProdVec_coorBN(giB0(1),giB0(2))).Normer();
Coordonnee ve(0.,-N(3),N(2)); // = ProdVec(N,I1)
double norve = ve.Norme();
int tail_Aa0 = Aa0.Nb_ligne(); // pour tenir compte d'une dim = 2 ou 3
Tableau <Coordonnee> vi(tail_Aa0); // les vecteurs plans orthonormes de la facette
if (norve >= ConstMath::petit)
{ vi(2) = ve.Normer();
vi(1) = Util::ProdVec_coor(vi(2),N);
}
else
{ ve.Change_Coordonnee(3,N(3),0.,-N(1)); // = ProdVec(I2,N)
vi(1) = ve.Normer();
vi(2) = Util::ProdVec_coor(N,vi(1));
};
if (tail_Aa0 == 3)
vi(3) = N;
if(giH0.NbVecteur()==tail_Aa0)
{for (int al=1 ;al<=tail_Aa0;al++)
for (int bl = 1;bl<=tail_Aa0;bl++)
Aa0(bl,al) = giH0.Coordo(bl) * vi(al) ;
}
else // sinon cela signifie que le nombre est < donc à 3, car on traîte de repère pour facette
{for (int al=1 ;al<=tail_Aa0;al++)
{for (int bl = 1;bl<=2;bl++)
Aa0(bl,al) = giH0.Coordo(bl) * vi(al) ;
Aa0(3,al) = N * vi(al) ; // on considère que le 3ième vecteur c'est la normale
};
};
// for (int al=1 ;al<=2;al++)
// {Aa0(1,al) = giH0.Coordo(1) * vi(al) ;
// Aa0(2,al) = giH0.Coordo(2) * vi(al) ;
// }
//------ cas de la config à t ,
N = (Util::ProdVec_coorBN(giB_t(1),giB_t(2))).Normer();
ve.Change_Coordonnee(3,0.,-N(3),N(2)); // = ProdVec_coor(N,I1)
norve = ve.Norme();
int tail_jtB = Aa_t.Nb_ligne(); // pour tenir compte d'une dim = 2 ou 3
Tableau <Coordonnee> jtB(tail_jtB);
if (norve >= ConstMath::petit)
{ jtB(2) = ve.Normer();
jtB(1) = Util::ProdVec_coor(jtB(2),N);
}
else
{ ve.Change_Coordonnee(3,N(3),0.,-N(1)); // = ProdVec_coor(I2,N)
jtB(1) = ve.Normer();
jtB(2) = Util::ProdVec_coor(N,jtB(1));
};
if (tail_jtB == 3)
jtB(3) = N;
if(giH_t.NbVecteur()==tail_jtB)
{for (int be=1 ;be<=tail_jtB;be++)
for (int bl = 1;bl<=tail_jtB;bl++)
Aa_t(bl,be) = giH_t.Coordo(bl) * jtB(be) ;
}
else // sinon cela signifie que le nombre est < donc à 3, car on traîte de repère pour facette
{for (int be=1 ;be<=tail_jtB;be++)
{for (int bl = 1;bl<=2;bl++)
Aa_t(bl,be) = giH_t.Coordo(bl) * jtB(be) ;
Aa_t(3,be) = N * jtB(be) ; // on considère que le 3ième vecteur c'est la normale
};
};
// for (int be=1;be<=2;be++)
// { Aa_t(1,be) = giH_t.Coordo(1) * jtB(be);
// Aa_t(2,be) = giH_t.Coordo(2) * jtB(be);
// }
//------ cas de la config tdt,
N = (Util::ProdVec_coorBN(giB_tdt(1),giB_tdt(2))).Normer();
ve.Change_Coordonnee(3,0.,-N(3),N(2)); // = ProdVec_coor(N,I1)
norve = ve.Norme();
int tail_jtdtB = Aa_tdt.Nb_ligne(); // pour tenir compte d'une dim = 2 ou 3
Tableau <Coordonnee> jtdtB(tail_jtdtB);
if (norve >= ConstMath::petit)
{ jtdtB(2) = ve.Normer();
jtdtB(1) = Util::ProdVec_coor(jtdtB(2),N);
}
else
{ ve.Change_Coordonnee(3,N(3),0.,-N(1)); // = ProdVec_coor(I2,N)
jtdtB(1) = ve.Normer();
jtdtB(2) = Util::ProdVec_coor(N,jtdtB(1));
};
if (tail_jtdtB == 3)
jtdtB(3) = N;
if(giH_tdt.NbVecteur()==tail_jtdtB)
{for (int be=1 ;be<=tail_jtdtB;be++)
for (int bl = 1;bl<=tail_jtdtB;bl++)
Aa_tdt(bl,be) = giH_tdt.Coordo(bl) * jtdtB(be) ;
}
else // sinon cela signifie que le nombre est < donc à 3, car on traîte de repère pour facette
{for (int be=1 ;be<=tail_jtdtB;be++)
{for (int bl = 1;bl<=2;bl++)
Aa_tdt(bl,be) = giH_tdt.Coordo(bl) * jtdtB(be) ;
Aa_tdt(3,be) = N * jtdtB(be) ; // on considère que le 3ième vecteur c'est la normale
};
};
// for (int be=1;be<=2;be++)
// { Aa_tdt(1,be) = giH_tdt.Coordo(1) * jtdtB(be);
// Aa_tdt(2,be) = giH_tdt.Coordo(2) * jtdtB(be);
// }
return;
};
// ------------------------ METHODES PROTEGEES : -------------------------------
// ----------------- méthodes de vérifications------- ----
void DeformationSfe1::VerifCal_def(bool gradV_instantane,const Met_abstraite::Impli & ,TenseurBB& epsBB_tdt
,Tableau <TenseurBB *> & d_epsBB_tdt)
{ // l'idée est de faire une vérification des dérivées à l'aide d'une méthode de différence finie
int dim = ParaGlob::Dimension();
// dans le cas du premier passage on indique qu'il y a vérification
if (indic_VerifCal_implicitSfe1 == 0)
{ cout << "\n ****vérification du calcul de la déformation et des éléments de la métrique associé****";
cout << "\n DeformationSfe1::VerifCal_def(... \n";
}
indic_VerifCal_implicitSfe1++;
// on cré une seconde métrique pour éviter de détruire la métrique originale
Met_Sfe1 metrique_bis(*((Met_Sfe1*)metrique));
// ici on considère que l'on a même nombre de ddl par noeud = dim
// on va modifier chaque ddl de chaque noeud systématiquement
int nbnoeud = tabnoeud->Taille();
// le deltat pour les différences finis
double delta = ConstMath::unpeupetit;
double mini_val = ConstMath::pasmalpetit;
int numddl = 1; // le compteur de ddl
bool erreur = false; // indicateur d'erreur
bool premier_calcul=true;
for (int inoeud=1;inoeud<=nbnoeud;inoeud++)
{// on récupère les coordonnées du noeud
Coordonnee coordtdt = (*tabnoeud)(inoeud)->Coord2();
for (int ix= 1;ix<=dim;ix++,numddl++)
{ Coordonnee X(dim); X(ix) += delta;
(*tabnoeud)(inoeud)->Ajout_coord2(X);
// appel de la metrique
const Met_abstraite::Expli_t_tdt& ex_n =
metrique_bis.Cal_explicit_tdt(*tabnoeud,premier_calcul,(*tabDphi)(numInteg),
nbNoeud,(*tabPhi)(numInteg),gradV_instantane);
TenseurBB * epsBB_tdt_n = NevezTenseurBB(epsBB_tdt);
// calcul de la base duale et de la métrique à t=0
const Met_abstraite::gijHH_0_et_giH_0& ex1_n = metrique_bis.Cal_gijHH_0_et_giH_0_apres_im_expli();
bool variation = false; // pour la variation de B et Palpha_BH
Tableau <TenseurBB *> d_epsBB_tdt_n(d_epsBB_tdt);
for (int i=1;i<= d_epsBB_tdt_n.Taille();i++) d_epsBB_tdt_n(i)=NevezTenseurBB(*d_epsBB_tdt(1));
// appel pour le calcul de la déformation logarithmique et de sa variation
// Cal_Logarithmique (*ex_n.gijBB_0,*ex1_n.gijHH_0,d_epsBB_tdt_n,*ex_n.gijBB_tdt,*ex_n.gijHH_tdt,*epsBB_tdt_n
// ,*ex_n.d_gijBB_tdt,variation);
// calcul des dérivées numériques et vérification
/* for (int j=1;j<=dim;j++)
{ // variation des vecteurs giB_tdt
CoordonneeB dgiB = ((*ex_n.giB_tdt)(j) -(*ex.giB_tdt)(j))/delta;
for (int i=1;i<=dim;i++)
if (diffpourcent(dgiB(i),(*ex.d_giB_tdt)(numddl)(j)(i),MaX(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))),0.05))
if (MiN(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))) <= mini_val)
{if ( MaX(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))) > 50.*delta) erreur = true;}
else erreur = true;
// variation des vecteurs giH_tdt
CoordonneeH dgiH = ((*ex_n.giH_tdt)(j) - (*ex.giH_tdt)(j))/delta;
for (int i=1;i<=dim;i++)
if (diffpourcent(dgiH(i),(*ex.d_giH_tdt)(numddl)(j)(i),MaX(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))),0.05))
if (MiN(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))) <= mini_val)
{if ( MaX(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))) > 50.*delta) erreur = true;}
else erreur = true;
} */
// variation du tenseur epsBB_tdt
TenseurBB * ddepsBB = NevezTenseurBB(epsBB_tdt);
*ddepsBB = (*epsBB_tdt_n - epsBB_tdt) / delta; // la dérivée numérique
for (int i1=1;i1<=dim;i1++)
for (int j1=1;j1<=dim;j1++)
if (diffpourcent((*ddepsBB)(i1,j1),(*(d_epsBB_tdt(numddl)))(i1,j1),
MaX(Dabs((*ddepsBB)(i1,j1)),Dabs((*(d_epsBB_tdt(numddl)))(i1,j1))),0.05))
{if (MiN(Dabs((*ddepsBB)(i1,j1)),Dabs((*(d_epsBB_tdt(numddl)))(i1,j1))) <= mini_val)
{if( MaX(Dabs((*ddepsBB)(i1,j1)),Dabs((*(d_epsBB_tdt(numddl)))(i1,j1))) > 50.*delta) erreur = true;}
else erreur = true;
};
/* // variation du tenseur gijHH_tdt
TenseurHH * gijHH = NevezTenseurHH(*ex_n.gijHH_tdt);
*gijHH = (*ex_n.gijHH_tdt - *ex.gijHH_tdt) / delta;
for (int i1=1;i1<=dim;i1++)
for (int j1=1;j1<=dim;j1++)
if (diffpourcent((*gijHH)(i1,j1),(*(*ex. d_gijHH_tdt)(numddl))(i1,j1),
MaX(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))),0.05))
if (MiN(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))) <= mini_val)
{if( MaX(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))) > 50.*delta) erreur = true;}
else erreur = true;
// variation du jacobien
double djaco = ((*ex_n.jacobien_tdt) - (*ex.jacobien_tdt))/delta;
if (diffpourcent(djaco,(*ex.d_jacobien_tdt)(numddl),MaX(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))),0.05))
if (MiN(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))) <= mini_val)
{if( MaX(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))) > 50.*delta) erreur = true;}
else erreur = true;
// effacement des tenseurs intermédiaires
delete gijBB; delete gijHH;
// maintenant on remet les coordonnées du noeud à l'état initial
(*tabnoeud)(inoeud)->Change_coord2(coordtdt); */
} // fin de boucle sur la dimension de coordonnée
} // fin de boucle sur les noeuds
// message d'erreur si besoin
if (erreur)
{ cout << "\n erreur dans le calcul analytique des dérivees de la metrique";
cout << "\n DeformationSfe1::VerifCal_def(.."
<< " , numero d'increment = " << indic_VerifCal_implicitSfe1;
Sortie(1);
}
};
void DeformationSfe1::VerifCal_implicit(bool gradV_instantane,const Met_abstraite::Impli & ex)
{ // l'idée est de faire une vérification des dérivées à l'aide d'une méthode de différence finie
int dim = ParaGlob::Dimension();
// dans le cas du premier passage on indique qu'il y a vérification
if (indic_VerifCal_implicitSfe1 == 0)
{ cout << "\n ****verification du calcul de la deformation et des elements de la metrique associe****";
cout << "\n DeformationSfe1::VerifCal_implicit \n";
}
indic_VerifCal_implicitSfe1++;
// on cré une seconde métrique pour éviter de détruire la métrique originale
Met_Sfe1 metrique_bis(*((Met_Sfe1*)metrique));
// ici on considère que l'on a même nombre de ddl par noeud = dim
// on va modifier chaque ddl de chaque noeud systématiquement
int nbnoeud = tabnoeud->Taille();
// le deltat pour les différences finis
double delta = ConstMath::unpeupetit;
double mini_val = ConstMath::pasmalpetit;
int numddl = 1; // le compteur de ddl
int nberr = 10;
Tableau<int> erreur(nberr);
double diff_admi = 0.1;
bool premier_calcul=true;
for (int inoeud=1;inoeud<=nbnoeud;inoeud++)
{// on récupère les coordonnées du noeud
Coordonnee coordtdt = (*tabnoeud)(inoeud)->Coord2();
for (int ix= 1;ix<=dim;ix++,numddl++)
{ Coordonnee X(dim); X(ix) += delta;
(*tabnoeud)(inoeud)->Ajout_coord2(X);
// appel de la métrique
const Met_abstraite::Expli_t_tdt& ex_n = metrique_bis.CalSfe1_explicit_tdt
(*tabnoeud,gradV_instantane,(*tabDphi)(numInteg_surf),nbNoeud
,(*tabPhi)(numInteg_surf),premier_calcul,(*tabDphiH)(numInteg_ep),(*tabPhiH)(numInteg_ep)
,epais,*tabTypeCL,*vplan);
premier_calcul=false;
// calcul des dérivées numériques et vérification
int nb_vecteur = 2;
for (int j=1;j<=nb_vecteur;j++)
{ // variation des vecteurs giB_tdt
CoordonneeB dgiB = ((*ex_n.giB_tdt)(j) -(*ex.giB_tdt)(j))/delta;
for (int i=1;i<=dim;i++)
if (diffpourcent(dgiB(i),(*ex.d_giB_tdt)(numddl)(j)(i),MaX(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))),diff_admi))
{if (MiN(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))) <= mini_val)
{if ( MaX(Dabs(dgiB(i)),Dabs((*ex.d_giB_tdt)(numddl)(j)(i))) > 50.*delta)
erreur(1) += 1;}
else
{erreur(2) += 1;
cout << "\ndgiB("<<i<<")="<<dgiB(i)<<",(*ex.d_giB_tdt)("<<numddl<<")("<<j<<")("<<i<<")="<< (*ex.d_giB_tdt)(numddl)(j)(i);
}
};
// variation des vecteurs giH_tdt
CoordonneeH dgiH = ((*ex_n.giH_tdt)(j) - (*ex.giH_tdt)(j))/delta;
for (int i=1;i<=dim;i++)
if (diffpourcent(dgiH(i),(*ex.d_giH_tdt)(numddl)(j)(i),MaX(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))),diff_admi))
{if (MiN(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))) <= mini_val)
{if ( MaX(Dabs(dgiH(i)),Dabs((*ex.d_giH_tdt)(numddl)(j)(i))) > 50.*delta) erreur(3) += 1;}
else erreur(4) += 1;
};
};
// variation du tenseur gijBB_tdt
TenseurBB * gijBB = NevezTenseurBB(*ex_n.gijBB_tdt);
*gijBB = (*ex_n.gijBB_tdt - *ex.gijBB_tdt) / delta;
for (int i1=1;i1<=nb_vecteur;i1++)
for (int j1=1;j1<=nb_vecteur;j1++)
if (diffpourcent((*gijBB)(i1,j1),(*(*ex. d_gijBB_tdt)(numddl))(i1,j1),
MaX(Dabs((*gijBB)(i1,j1)),Dabs((*(*ex. d_gijBB_tdt)(numddl))(i1,j1))),diff_admi))
{if (MiN(Dabs((*gijBB)(i1,j1)),Dabs((*(*ex. d_gijBB_tdt)(numddl))(i1,j1))) <= mini_val)
{if( MaX(Dabs((*gijBB)(i1,j1)),Dabs((*(*ex. d_gijBB_tdt)(numddl))(i1,j1))) > 50.*delta) erreur(5) += 1;}
else erreur(6) += 1;
};
// variation du tenseur gijHH_tdt
TenseurHH * gijHH = NevezTenseurHH(*ex_n.gijHH_tdt);
*gijHH = (*ex_n.gijHH_tdt - *ex.gijHH_tdt) / delta;
for (int i1=1;i1<=nb_vecteur;i1++)
for (int j1=1;j1<=nb_vecteur;j1++)
if (diffpourcent((*gijHH)(i1,j1),(*(*ex. d_gijHH_tdt)(numddl))(i1,j1),
MaX(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))),diff_admi))
{if (MiN(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))) <= mini_val)
{if( MaX(Dabs((*gijHH)(i1,j1)),Dabs((*(*ex. d_gijHH_tdt)(numddl))(i1,j1))) > 50.*delta) erreur(7) += 1;}
else erreur(8) += 1;
};
// variation du jacobien
double djaco = ((*ex_n.jacobien_tdt) - (*ex.jacobien_tdt))/delta;
if (diffpourcent(djaco,(*ex.d_jacobien_tdt)(numddl),MaX(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))),diff_admi))
{if (MiN(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))) <= mini_val)
{if( MaX(Dabs(djaco),Dabs((*ex.d_jacobien_tdt)(numddl))) > 50.*delta)
{erreur(9) += 1; //(*ex.d_jacobien_tdt)(numddl) = djaco; // pour voir l'implication d'une bonne dérivée de jacobien
}
}
else erreur(10) += 1;
};
// effacement des tenseurs intermédiaires
delete gijBB; delete gijHH;
// maintenant on remet les coordonnées du noeud à l'état initial
(*tabnoeud)(inoeud)->Change_coord2(coordtdt);
} // fin de boucle sur la dimension de coordonnée
} // fin de boucle sur les noeuds
// message d'erreur si besoin
bool une_erreur=false;
for (int l=1;l<=nberr;l++) if (erreur(l) != 0) une_erreur=true;
if (une_erreur)
{ cout << "\n erreur dans le calcul analytique des derivees de la metrique";
cout << "\n DeformationSfe1::VerifCal_implicit(.."
<< " , numero d'increment = " << indic_VerifCal_implicitSfe1 << " erreur = " << erreur << endl;
// Sortie(1);
}
};
Reference in a new issue View git blame Copy permalink