1041 lines
48 KiB
C++
1041 lines
48 KiB
C++
|
|
// 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 "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);
|
|
}
|
|
};
|
|
|