rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Elements/Mecanique/Deformation_gene/DeformationPP.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

467 lines
20 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 "DeformationPP.h"
# include "Met_PiPoCo.h"
#include "ConstMath.h"
#include "ParaGlob.h"
#include "Util.h"
// il faut regarder et mettre à jour le calcul des différentes déformations ********
// il faut regarder dans déformation, en particulier il faut mettre à jour, ***********
// si nécessaire différents cas de déformation **********************
// il faut également mettre à jour l'influence de l'indicateur premier_calcul ????????????
// dans le cas du premier passage, pour l'instant pas fait !!!!!!!!!!!!!!!!!!!!!!!!!!
// -------------------------- variables static -------------------
int DeformationPP::numInteg_ep = 0;
int DeformationPP::nbtotalep = 0;
int DeformationPP::nbtotalaxpl = 0;
Vecteur DeformationPP::theta_z(1);
// on utilise deux types d'interpolation
Tableau <Mat_pleine const *> DeformationPP::taDphi(2);
Tableau <Vecteur const *> DeformationPP::taPhi(2);
// ---------- constructeur----------------------------------------
DeformationPP::DeformationPP () // constructeur ne devant pas etre utilise
{
#ifdef MISE_AU_POINT
{ cout << "\nErreur : le constructeur par defaut ne doit pa etre utilise !\n";
cout << "DeformationPP::DeformationPP () \n";
Sortie(1);
};
#endif
};
// constructeur normal dans le cas d'un ou de plusieurs pt d'integration
DeformationPP::DeformationPP (Met_abstraite & a,Tableau<Noeud *>& tabnoeud
,Tableau <Mat_pleine> const & tDphH,Tableau <Vecteur> const & tPhH
,Tableau <Mat_pleine> const & tDphS,Tableau <Vecteur> const & tPhS ):
Deformation (a,tabnoeud,tDphS,tPhS )
{ type_deformation = DEFORMATION_POUTRE_PLAQUE_STANDART;
tabDphiH = &(tDphH);
tabPhiH = &(tPhH);
// a priori pas de numero d'integration affectes
numInteg = 0;
numInteg_ep = 0;
};
// constructeur de copie
DeformationPP::DeformationPP (const DeformationPP& a) :
Deformation(a)
{ numInteg_ep = a.numInteg_ep;
tabDphiH = a.tabDphiH;
tabPhiH = a.tabPhiH;
};
DeformationPP::~DeformationPP ()
{ };
// ============ METHODES PUBLIQUES : ==================
// Surcharge de l'operateur = : realise l'affectation
// fonction virtuelle
Deformation& DeformationPP::operator= (const Deformation& )
{ // normalement ne devrait pas être utilisé
cout << "\n erreur , l operateur d affectation a utiliser doit etre celui explicite "
<< " de la classe DeformationPP \n"
<< " Deformation& DeformationPP::operator= (const Deformation& def) \n";
Sortie(1);
return (*this);
};
// fonction normale
DeformationPP& DeformationPP::operator= (const DeformationPP& def)
{ tabDphiH = def.tabDphiH;
tabPhiH = def.tabPhiH;
(*this) = Deformation::operator=(def);
return (*this);
};
// change les numeros d'integration de surface et d'epaisseur courant
void DeformationPP::ChangeNumIntegSH
(int nisurf, int niepaiss)
{ //PiPoCo & elem = *((PiPoCo*) element);
numInteg_ep = niepaiss; numInteg = nisurf;
// on fait les changements dus aux nouveaux pts integ
AppliquePtInteg();
} ;
// calcul explicit à t :tous les parametres sont de resultats
const Met_abstraite::Expli& DeformationPP::Cal_explicit_t
( const Tableau <double>& def_equi_t,TenseurBB & epsBB_t,Tableau <TenseurBB *> & d_epsBB
,Tableau <double>& def_equi,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
const Met_abstraite::Expli& ex = met_pipoco->Cal_explicit_t
(*tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
/// voir Deformation car ça a changé !!
/* // epsBB_t est dimensionne dans l'element
epsBB_t = 0.5 * ( *(ex.gijBB_t) - *(ex.gijBB_0));
// ici on considère que le delta_epsBB=epsBB_t ! c-a-d le delta de 0 à t
DeltaEpsBB = epsBB_t;
// calcul simplifié éventuelle de la vitesse de déformation si les ddl vitesses ne sont pas présent
if (pas_de_gradV)
{ // on choisit une vitesse de déformation pour l'instant identique à deltaeps/t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul on garde la vitesse actuelle
double deltat=vartemps.IncreTempsCourant();
if (deltat >= ConstMath::trespetit)
DepsBB = DeltaEpsBB/deltat;
}
else // cas où le gradient a été calculé
DepsBB = 0.5 * ((*ex.gradVBB_t) + ex.gradVBB_t->Transpose());
// variation de la déformation / au ddl
int d_epsBBTaille = d_epsBB.Taille();
for (int i=1; i<= d_epsBBTaille; i++)
*(d_epsBB(i)) = 0.5 * (*((*(ex.d_gijBB_t))(i)));*/
return ex;
};
// calcul explicit à tdt :tous les parametres sont de resultats
const Met_abstraite::Expli_t_tdt& DeformationPP::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_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
const Met_abstraite::Expli_t_tdt& ex= met_pipoco->Cal_explicit_tdt
(*tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
/// voir Deformation car ça a changé !!
/* // epsBB_tdt est dimensionne auparavant
epsBB_tdt = 0.5 * ( *(ex.gijBB_t) - *(ex.gijBB_0));
// epsBB_tdt est dimensionne auparavant
delta_epsBB_tdt = 0.5 * ( *(ex.gijBB_tdt) - *(ex.gijBB_t));
if (pas_de_gradV)
{ // on choisit une vitesse de déformation pour l'instant identique à deltaeps/t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul on garde la vitesse actuelle
double deltat=vartemps.IncreTempsCourant();
if (deltat >= ConstMath::trespetit)
DepsBB = delta_epsBB_tdt/deltat;
}
else // cas où le gradient a été calculé
DepsBB = 0.5 * ((*ex.gradVBB_tdt) + ex.gradVBB_tdt->Transpose());
// variation de la déformation / au ddl
int d_epsBBTaille = d_epsBB.Taille();
for (int i=1; i<= d_epsBBTaille; i++)
*(d_epsBB(i)) = 0.5 * (*((*(ex.d_gijBB_tdt))(i)));*/
return ex;
};
// cas implicite : tous les parametres sont de resultats
const Met_abstraite::Impli& DeformationPP::Cal_implicit
( const Tableau <double>& def_equi_t,TenseurBB & epsBB_tdt,Tableau <TenseurBB *> & d_epsBB_tdt
,Tableau <double>& def_equi,Tableau2 <TenseurBB *>& d2_epsBB_tdt
,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_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
// 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
const Met_abstraite::Impli& ex =met_pipoco->Cal_implicit ( *tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
/// voir Deformation car ça a changé !!
/* epsBB_tdt = 0.5 * (*(ex.gijBB_tdt) - *(ex.gijBB_0));
delta_epsBB = 0.5 * (*(ex.gijBB_tdt) - *(ex.gijBB_t));
if (pas_de_gradV)
{ // on choisit une vitesse de déformation pour l'instant identique à deltaeps/t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul on garde la vitesse actuelle
double deltat=vartemps.IncreTempsCourant();
if (deltat >= ConstMath::trespetit)
DepsBB = delta_epsBB/deltat;
}
else // cas où le gradient a été calculé
DepsBB = 0.5 * ((*ex.gradVBB_tdt) + ex.gradVBB_tdt->Transpose());
// variation de la déformation / au ddl
int d_epsBB_tdtTaille = d_epsBB_tdt.Taille();
for (int i=1; i<= d_epsBB_tdtTaille; i++)
*(d_epsBB_tdt(i)) = 0.5 * (*((*(ex.d_gijBB_tdt))(i)));
// calcul éventuelle de la dérivée seconde de la déformation
if (pa.Var_D())
{// recup des variations secondes de la déformation
int d2_epsBB_tdtTaille1 = d2_epsBB_tdt.Taille1();
for (int i=1; i<= d2_epsBB_tdtTaille1; i++)
for (int j=1; j<= i; j++) // symétrie du tableau et du tenseur
{ *(d2_epsBB_tdt(i,j)) = 0.5 * (*((*(ex.d2_gijBB_tdt))(i,j))) ;
*(d2_epsBB_tdt(j,i)) = *(d2_epsBB_tdt(i,j)) ;
}
} */
return ex;
};
// ---------------- calcul des variables primaires autre que pour la mécanique --------
// ------------ donc par de retour relatif aux déformations
// calcul explicit à t :tous les parametres sont de resultats
const Met_abstraite::Expli& DeformationPP::Cal_explicit_t(bool premier_calcul )
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
// appel de la metrique
const Met_abstraite::Expli& ex = met_pipoco->Cal_explicit_t(*tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
return ex;
};
// calcul explicit à tdt :tous les parametres sont de resultats
const Met_abstraite::Expli_t_tdt& DeformationPP::Cal_explicit_tdt(bool premier_calcul )
{ bool gradV_instantane = false; // ************ pour l'instant figé
// appel de la metrique
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
// appel de la metrique
const Met_abstraite::Expli_t_tdt& ex = met_pipoco->Cal_explicit_tdt(*tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
return ex;
};
// cas implicite : tous les parametres sont de resultats
const Met_abstraite::Impli& DeformationPP::Cal_implicit( bool premier_calcul)
{ bool gradV_instantane = false; // ************ pour l'instant figé
// recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
// 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
const Met_abstraite::Impli& ex =met_pipoco->Cal_implicit ( *tabnoeud,gradV_instantane,taDphi,nbNoeud,taPhi,premier_calcul);
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 DeformationPP::RemontImp(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoImp ex = met_pipoco->Cal_InfoImp
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_tdt);
const BaseH & giH0 = *(ex.giH_0);
const BaseH & giH = *(ex.giH_tdt);
// on différencie le cas des poutres et celui des plaques
int dim = giB0.NbVecteur();
if (dim == 1) // cas de la dimension 1 c-a-dire poutre
Deformation::BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin); // générale
else
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin); // particulier plaques
return ex;
};
// cas sortie d'un calcul implicit
// sans les matrices de passage
const Met_abstraite::InfoImp DeformationPP::RemontImp()
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoImp ex = met_pipoco->Cal_InfoImp
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_tdt);
const BaseH & giH0 = *(ex.giH_0);
const 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 DeformationPP::RemontExp_t(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoExp_t ex = met_pipoco->Cal_InfoExp_t
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_t);
const BaseH & giH0 = *(ex.giH_0);
const BaseH & giH = *(ex.giH_t);
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin);
return ex;
};
// cas sortie d'un calcul explicit à t
// sans les matrices de passage
const Met_abstraite::InfoExp_t DeformationPP::RemontExp_t()
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoExp_t ex = met_pipoco->Cal_InfoExp_t
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_t);
const BaseH & giH0 = *(ex.giH_0);
const 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 DeformationPP::RemontExp_tdt(bool absolue,Mat_pleine& Aa0,Mat_pleine& Aafin)
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoExp_tdt ex = met_pipoco->Cal_InfoExp_tdt
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_tdt);
const BaseH & giH0 = *(ex.giH_0);
const BaseH & giH = *(ex.giH_tdt);
BasePassage(absolue,giB0,giB,giH0,giH,Aa0,Aafin);
return ex;
};
// cas sortie d'un calcul explicit à tdt
// sans les matrices de passage
const Met_abstraite::InfoExp_tdt DeformationPP::RemontExp_tdt()
{ // recup d'un pointeur sur la metrique sfe1
Met_PiPoCo* met_pipoco = (Met_PiPoCo*) metrique;
Met_abstraite::InfoExp_tdt ex = met_pipoco->Cal_InfoExp_tdt
( *tabnoeud,taDphi,taPhi,nbNoeud);
// determination des matrices de transformation de base
const BaseB & giB0 = *(ex.giB_0);
const BaseB & giB = *(ex.giB_tdt);
const BaseH & giH0 = *(ex.giH_0);
const BaseH & giH = *(ex.giH_tdt);
return ex;
};
// gestion du parcours de tous les points d'integration
// bien voir que numInteg est relatif aux pt d'intégration de l'axe
void DeformationPP::PremierPtInteg()
{ nbtotalaxpl = tabPhi->Taille();
nbtotalep = tabPhiH->Taille();
numInteg = 1 ; numInteg_ep = 1;
// on fait les changements dus aux nouveaux pts integ
AppliquePtInteg();
};
bool DeformationPP::DernierPtInteg()
{ if (numInteg <= nbtotalaxpl)
return true;
else
return false;
};
void DeformationPP::NevezPtInteg()
{ if (numInteg_ep < nbtotalep)
numInteg_ep++;
else
{ numInteg++;
numInteg_ep = 1;
}
// on fait les changements dus aux nouveaux pts integ
// dans le cas ou ils sont valides
if (numInteg <= nbtotalaxpl)
AppliquePtInteg();
};
// ------------------------ METHODES PROTEGEES : -------------------------------
// 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 DeformationPP::BasePassage
(bool absolue,const BaseB & giB0,const BaseB & giB,const BaseH & giH0,const BaseH & giH,
Mat_pleine& Aa0,Mat_pleine& Aafin)
{
// determination des matrices de transformation de base
// l'objectif est de determiner un repere pertinant dans le cas de plaque , coque .
// Dans le cas d'une dimension globale 3D avec des plaques ou coque ->
// 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();
Tableau <Coordonnee> vi(2); // 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));
}
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 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();
Tableau <Coordonnee> Aa(2);
if (norve >= ConstMath::petit)
{ 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));
}
for (int be=1;be<=2;be++)
{ Aafin(1,be) = giH.Coordo(1) * Aa(be);
Aafin(2,be) = giH.Coordo(2) * Aa(be);
}
return;
};
// applique les conséquences d'un changement de numéro de point d'intégration
// par exemple effectué via NevezPtInteg() ou ChangeNumIntegSH
void DeformationPP::AppliquePtInteg()
{ //PiPoCo & elem = *((PiPoCo*) element);
// on est obligé de préciser le caractère réel du tableau ?
//------- pour l'instant c'est inopérationnelle: les 3 lignes qui suivent donne une erreur à la compilation
// taPhi(1) = & ((Vecteur const)((*tabPhi)(numInteg)));
// taDphi(1) = &((Mat_pleine const)((*tabDphi)(numInteg)));
// taDphi(2) = &((Mat_pleine const)((*tabDphiH)(numInteg_ep)));
// calcul de la cote en epaisseur
// les trois lignes suivantes ont été mise en commentaire car on ne peut plus
// accèder à l'élément directement, a moins par exemple de le passer en
// paramètre ou de trouver une autre technique pour avoir les infos a doc
cout << "\n pour l'instant la méthode n'est pas disponible cf le listing";
cout << " void DeformationPP::AppliquePtInteg()";
Sortie(1);
// double epaisseur = elem.H();
// theta_z(1) = 0.5 * epaisseur * (elem.KSIepais(numInteg_ep));
// taPhi(2) = & theta_z;
} ;
Reference in a new issue View git blame Copy permalink