rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

V 7.012 : résolution du pb de l'utilisation de l'accélération dans une fonction nD

Browse source 
Introduction du calcul de l'accélération interpolée, au niveau de la métrique
Intro de nouveaux affichages au niveau des fonctions nD
This commit is contained in:
Gérard Rio 2023-06-01 08:47:54 +02:00
parent 9c402fb5d8
commit ece68c42db
14 changed files with 554 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Elements/Mecanique/Deformation_gene/Deformation.cc
View file

@ -638,6 +638,8 @@ void Deformation::DeformationThermoMecanique(const double& temperature_0,const T
delta_epsBB_meca = delta_epsBB_totale - delta_epsBB_therm; // pour la déformation
DepsBB_meca = DepsBB_totale - DepsBB_therm; // pour la vitesse de déformation
};
// -- debug
if (!pas_de_metrique_dispo)
{cout << "\n debug Deformation::DeformationThermoMecanique( ";

15
Elements/Mecanique/Deformation_gene/Deformation.h
View file

@ -486,6 +486,21 @@ class Deformation
{return metrique->D_VitesseM_tdt((*tabnoeud)(num_noeud),ddl_vitesse);};
virtual const Tableau <Coordonnee>& Der_VitesseM_tdt(bool& ddl_vitesse,const Noeud* noe) // à t
{return metrique->D_VitesseM_tdt(noe,ddl_vitesse);};
// calcul des accélération dans le repère absolu du point d'intégration
// à priori on calcul au point d'intégration
virtual const Coordonnee& AccelerationM_0() {return metrique->AccelerationM_0(*tabnoeud,(*tabPhi)(numInteg));};
virtual const Coordonnee& AccelerationM_0(int num_n) {return metrique->AccelerationM_0((*tabnoeud)(num_n));};
virtual const Coordonnee& AccelerationM_0(const Noeud* noe) {return metrique->AccelerationM_0(noe);};
virtual const Coordonnee& AccelerationM_t() {return metrique->AccelerationM_t(*tabnoeud,(*tabPhi)(numInteg));};
virtual const Coordonnee& AccelerationM_t(int num_n) {return metrique->AccelerationM_t((*tabnoeud)(num_n));};
virtual const Coordonnee& AccelerationM_t(const Noeud* noe) {return metrique->AccelerationM_t(noe);};
virtual const Coordonnee& AccelerationM_tdt() {return metrique->AccelerationM_tdt(*tabnoeud,(*tabPhi)(numInteg));};
virtual const Coordonnee& AccelerationM_tdt(int num_n) {return metrique->AccelerationM_tdt((*tabnoeud)(num_n));};
virtual const Coordonnee& AccelerationM_tdt(const Noeud* noe) {return metrique->AccelerationM_tdt(noe);};
// détermination d'une bases particulière orthonormée pour représenter les tenseurs
// en sortie on a une (ou plusieurs) matrices de passage, qui permettent de passer de la base curviligne

51
Elements/Mecanique/Deformation_gene/Met_abstraite.h
View file

@ -366,7 +366,33 @@ class Met_abstraite
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi,bool ddl_vitesse);
// idem mais au noeud passé en paramètre
virtual const Tableau<Coordonnee> & D_VitesseM_tdt (const Noeud* noeud,bool ddl_vitesse);
// calcul de l'accélération du point M en fonction de phi et des coordonnees a 0
// dans le cas où les ddl d'accélération existent, ils sont directement interpolés
// sinon erreur
virtual const Coordonnee & AccelerationM_0 // ( stockage a t=0)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi);
// idem mais au noeud passé en paramètre
virtual const Coordonnee & AccelerationM_0 (const Noeud* noeud);
// idem à t
virtual const Coordonnee & AccelerationM_t // ( stockage a t=t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi);
// idem mais au noeud passé en paramètre
virtual const Coordonnee & AccelerationM_t (const Noeud* noeud);
// idem à tdt
virtual const Coordonnee & AccelerationM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi);
// idem mais au noeud passé en paramètre
virtual const Coordonnee & AccelerationM_tdt (const Noeud* noeud);
// vérification existance des conteneurs d'accélérations
bool Existe_conteneur_acceleration0() const {return (gamma0 ==NULL) ? false : true; };
bool Existe_conteneur_accelerationt() const {return (gammat ==NULL) ? false : true; };
bool Existe_conteneur_accelerationtdt() const {return (gammatdt ==NULL) ? false : true; };
bool Existe_conteneur_acceleration() const
{return ((gammatdt ==NULL)||(gammat ==NULL)||(gamma0 ==NULL)) ? false : true; }
// calcul de la base naturel , au point correspondant au dphi en fonction des coord a t=0
virtual const BaseB& BaseNat_0 // ( stockage a t=0)
(const Tableau<Noeud *>& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi);
@ -484,6 +510,23 @@ class Met_abstraite
(const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud);
// idem mais au noeud passé en paramètre
virtual void Calcul_d_V_moytdt (const Noeud* noeud);
//--- cas des accélérations
// calcul de l'accélération du point a t0 en fonction des ddl existants d'accélération
virtual void Calcul_gamma0
( const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud);
// idem mais au noeud passé en paramètre
virtual void Calcul_gamma0 (const Noeud* noeud);
// idem a t
virtual void Calcul_gammat
(const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud);
// idem mais au noeud passé en paramètre
virtual void Calcul_gammat (const Noeud* noeud);
// idem à tdt
virtual void Calcul_gammatdt
(const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud);
// idem mais au noeud passé en paramètre
virtual void Calcul_gammatdt (const Noeud* noeud);
//== par defaut le nombre de vecteur de base est celui de la dimension du
//== probleme transmis par paraglob
@ -612,8 +655,12 @@ class Met_abstraite
Tableau<Coordonnee> V_moy_t,V_moy_tdt; // variable interne: vitesse moyenne à t et tdt en chaque noeud r,
// calculé dans le calcul du gradient utilisé, dans le calcul de la variation du gradient moyen
BaseB * dmatV_moy_t,* dmatV_moy_tdt; // variable interne: dérivée par rapport au repère
// matériel (d/dteta_i) au point interpolé
// matériel (d/dteta_i) au point interpolé
Coordonnee * gamma0; // accélération du point a t=0
Coordonnee * gammat ; // accélération du point a l'instant t
Coordonnee * gammatdt; // accélération du point a l'instant t+dt
BaseB * giB_0 ; // base naturelle a t=0
BaseB * giB_t ; // base naturelle a t
BaseB * giB_tdt ; // base naturelle a t+dt

96
Elements/Mecanique/Deformation_gene/Met_abstraite1s2.cc
View file

@ -54,6 +54,7 @@ d_gijBB_t(),d_gijBB_tdt(),d2_gijBB_tdt(),d_gijHH_t(),d_gijHH_tdt(),d_jacobien_t(
{ dim_base = 0; nbvec_base = 0;
M0 = NULL;Mt = NULL;d_Mt = NULL;Mtdt = NULL;d_Mtdt = NULL;
V0 = NULL;Vt = NULL;d_Vt = NULL;Vtdt = NULL;d_Vtdt = NULL;
gamma0 = NULL;gammat = NULL;gammatdt = NULL;
giB_0 = NULL;giB_t = NULL; giB_tdt = NULL;
giH_0 = NULL;giH_t = NULL;giH_tdt = NULL;
gijBB_0 = NULL;gijBB_t = NULL;gijBB_tdt = NULL;
@ -96,14 +97,15 @@ Met_abstraite::Met_abstraite (const Met_abstraite& a) :
{ // on met à NULL les grandeurs pointées
M0 = NULL;Mt = NULL;d_Mt = NULL;Mtdt = NULL;d_Mtdt = NULL;
V0 = NULL;Vt = NULL;d_Vt = NULL;Vtdt = NULL;d_Vtdt = NULL;
gamma0 = NULL;gammat = NULL;gammatdt = NULL;
giB_0 = NULL;giB_t = NULL; giB_tdt = NULL;
giH_0 = NULL;giH_t = NULL;giH_tdt = NULL;
gijBB_0 = NULL;gijBB_t = NULL;gijBB_tdt = NULL;
gijHH_0 = NULL;gijHH_t = NULL;gijHH_tdt = NULL;
gradVmoyBB_t = NULL; gradVmoyBB_tdt = NULL;
gradVBB_t = NULL; gradVBB_tdt = NULL;
dmatV_moy_t = NULL; dmatV_moy_tdt = NULL;
d_giB_t = NULL;d_giB_tdt = NULL;
giH_0 = NULL;giH_t = NULL;giH_tdt = NULL;
gijBB_0 = NULL;gijBB_t = NULL;gijBB_tdt = NULL;
gijHH_0 = NULL;gijHH_t = NULL;gijHH_tdt = NULL;
gradVmoyBB_t = NULL; gradVmoyBB_tdt = NULL;
gradVBB_t = NULL; gradVBB_tdt = NULL;
dmatV_moy_t = NULL; dmatV_moy_tdt = NULL;
d_giB_t = NULL;d_giB_tdt = NULL;
d_giH_t = NULL;d_giH_tdt = NULL;
// on recopie les grandeurs
Copie_met(a);
@ -203,7 +205,13 @@ void Met_abstraite::Affiche() const
if (Existe(tab,idVtdt) && (d_Vtdt == NULL) )
{Coordonnee toto(dim_base); d_Vtdt = new Tableau <Coordonnee> (nbddl_x,toto);
tabbool(Existe_num(tab,idVtdt))=true;}
if (Existe(tab,igiB_0) && (giB_0 == NULL) )
if (Existe(tab,igamma0) && (gamma0 == NULL) )
{gamma0 = new Coordonnee(dim_base);tabbool(Existe_num(tab,igamma0))=true;}
if (Existe(tab,igammat) && (gammat == NULL) )
{gammat = new Coordonnee(dim_base);tabbool(Existe_num(tab,igammat))=true;}
if (Existe(tab,igammatdt) && (gammatdt == NULL) )
{gammatdt = new Coordonnee(dim_base);tabbool(Existe_num(tab,igammatdt))=true;}
if (Existe(tab,igiB_0) && (giB_0 == NULL) )
{giB_0 = new BaseB(dim_base,nbvec_base);tabbool(Existe_num(tab,igiB_0))=true;}
if (Existe(tab,igiB_t) && (giB_t == NULL) )
{giB_t = new BaseB(dim_base,nbvec_base);tabbool(Existe_num(tab,igiB_t))=true;}
@ -406,39 +414,43 @@ int Met_abstraite::Existe_num(Tableau<Enum_variable_metrique>& tab,const Enum_va
// allocation de la memoire
void Met_abstraite::Allocation ()
{
// on met les pointeurs a NULL
M0 = NULL;Mt = NULL;d_Mt = NULL;Mtdt = NULL;d_Mtdt = NULL;
V0 = NULL;Vt = NULL;d_Vt = NULL;Vtdt = NULL;d_Vtdt = NULL;
giB_0 = NULL;giB_t = NULL; giB_tdt = NULL;
giH_0 = NULL;giH_t = NULL;giH_tdt = NULL;
gijBB_0 = NULL;gijBB_t = NULL;gijBB_tdt = NULL;
gijHH_0 = NULL;gijHH_t = NULL;gijHH_tdt = NULL;
gradVmoyBB_t = NULL; gradVmoyBB_tdt = NULL;
gradVBB_t = NULL; gradVBB_tdt = NULL;
dmatV_moy_t = NULL; dmatV_moy_tdt = NULL;
d_giB_t = NULL;d_giB_tdt = NULL;
d_giH_t = NULL;d_giH_tdt = NULL;
// on alloue en fonction des parametres
int nbddl_x = tab_ddl.NbDdl_famille(X1); // nombre de ddl en position
nbddl_x += nbddl_sup_xi; // on tiens compte de ddl sup éventuels
int nbddl_v = tab_ddl.NbDdl_famille(V1); // nombre de ddl en vitesse
nbddl_v += nbddl_sup_xi; // on tiens compte de ddl sup éventuels
{
// on met les pointeurs a NULL
M0 = NULL;Mt = NULL;d_Mt = NULL;Mtdt = NULL;d_Mtdt = NULL;
V0 = NULL;Vt = NULL;d_Vt = NULL;Vtdt = NULL;d_Vtdt = NULL;
gamma0 = NULL;gammat = NULL;gammatdt = NULL;
giB_0 = NULL;giB_t = NULL; giB_tdt = NULL;
giH_0 = NULL;giH_t = NULL;giH_tdt = NULL;
gijBB_0 = NULL;gijBB_t = NULL;gijBB_tdt = NULL;
gijHH_0 = NULL;gijHH_t = NULL;gijHH_tdt = NULL;
gradVmoyBB_t = NULL; gradVmoyBB_tdt = NULL;
gradVBB_t = NULL; gradVBB_tdt = NULL;
dmatV_moy_t = NULL; dmatV_moy_tdt = NULL;
d_giB_t = NULL;d_giB_tdt = NULL;
d_giH_t = NULL;d_giH_tdt = NULL;
// on alloue en fonction des parametres
int nbddl_x = tab_ddl.NbDdl_famille(X1); // nombre de ddl en position
nbddl_x += nbddl_sup_xi; // on tiens compte de ddl sup éventuels
int nbddl_v = tab_ddl.NbDdl_famille(V1); // nombre de ddl en vitesse
nbddl_v += nbddl_sup_xi; // on tiens compte de ddl sup éventuels
if (Existe(tab,iM0)) M0 = new Coordonnee(dim_base);
if (Existe(tab,iMt)) Mt = new Coordonnee(dim_base);
if (Existe(tab,idMt))
{Coordonnee toto(dim_base); d_Mt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,iMtdt)) Mtdt = new Coordonnee(dim_base);
if (Existe(tab,idMtdt))
{Coordonnee toto(dim_base); d_Mtdt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,iV0)) V0 = new Coordonnee(dim_base);
if (Existe(tab,iM0)) M0 = new Coordonnee(dim_base);
if (Existe(tab,iMt)) Mt = new Coordonnee(dim_base);
if (Existe(tab,idMt))
{Coordonnee toto(dim_base); d_Mt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,iMtdt)) Mtdt = new Coordonnee(dim_base);
if (Existe(tab,idMtdt))
{Coordonnee toto(dim_base); d_Mtdt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,iV0)) V0 = new Coordonnee(dim_base);
if (Existe(tab,iVt)) Vt = new Coordonnee(dim_base);
if (Existe(tab,idVt))
{Coordonnee toto(dim_base); d_Vt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,iVtdt)) Vtdt = new Coordonnee(dim_base);
if (Existe(tab,idVtdt))
{Coordonnee toto(dim_base); d_Vtdt = new Tableau <Coordonnee> (nbddl_x,toto);}
if (Existe(tab,igamma0)) gamma0 = new Coordonnee(dim_base);
if (Existe(tab,igammat)) gammat = new Coordonnee(dim_base);
if (Existe(tab,igammatdt)) gammatdt = new Coordonnee(dim_base);
if (Existe(tab,igiB_0)) giB_0 = new BaseB(dim_base,nbvec_base);
if (Existe(tab,igiB_t)) giB_t = new BaseB(dim_base,nbvec_base);
if (Existe(tab,igiB_tdt)) giB_tdt = new BaseB(dim_base,nbvec_base);
@ -530,6 +542,9 @@ void Met_abstraite::Deallocation( Tableau<Enum_variable_metrique>& tib)
if (Existe(tib,idVt)) {delete d_Vt;d_Vt=NULL;};
if (Existe(tib,iVtdt)) {delete Vtdt;Vtdt=NULL;};
if (Existe(tib,idVtdt)) {delete d_Vtdt;d_Vtdt=NULL;};
if (Existe(tib,igamma0)) {delete gamma0;gamma0=NULL;};
if (Existe(tib,igammat)) {delete gammat;gammat=NULL;};
if (Existe(tib,igammatdt)) {delete gammatdt;gammatdt=NULL;};
if (Existe(tib,igiB_0)) {delete giB_0;giB_0=NULL;};
if (Existe(tib,igiB_t)) {delete giB_t;giB_t=NULL;};
if (Existe(tib,igiB_tdt)) {delete giB_tdt;giB_tdt=NULL;};
@ -632,7 +647,18 @@ void Met_abstraite::Copie_met(const Met_abstraite& a)
if (a.d_Vtdt != NULL)
{if (d_Vtdt==NULL) d_Vtdt = new Tableau <Coordonnee> (*(a.d_Vtdt)); else *d_Vtdt=*a.d_Vtdt;}
else {if (d_Vtdt != NULL) {delete d_Vtdt;d_Vtdt=NULL;}}
if (a.giB_0 != NULL)
if (a.gamma0 != NULL)
{if (gamma0==NULL) gamma0 = new Coordonnee(*(a.gamma0)); else *gamma0=*a.gamma0;}
else {if (gamma0!=NULL) {delete gamma0;gamma0=NULL;}}
if (a.gammat != NULL)
{if (gammat==NULL) gammat = new Coordonnee(*(a.gammat)); else *gammat=*a.gammat;}
else {if (gammat!=NULL) {delete gammat;gammat=NULL;}}
if (a.gammatdt != NULL)
{if (gammatdt==NULL) gammatdt = new Coordonnee(*(a.gammatdt)); else *gammatdt=*a.gammatdt;}
else {if (gammatdt!=NULL) {delete gammatdt;gammatdt=NULL;}}
if (a.giB_0 != NULL)
{if (giB_0==NULL) giB_0 = new BaseB(*(a.giB_0)); else *giB_0=*a.giB_0;}
else {if (giB_0!=NULL) {delete giB_0;giB_0 = NULL;}}
if (a.giB_t != NULL)

74
Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc
View file

@ -711,7 +711,79 @@ const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_tdt(const Noeud* noeud,boo
else { Calcul_d_V_moytdt(noeud); ddl_vitesse = false; };
return *d_Vtdt;
};
// calcul de l'accélération du point M en fonction de phi et des coordonnees a 0
// dans le cas où les ddl d'accélération existent, ils sont directement interpolés
// sinon erreur
const Coordonnee & Met_abstraite::AccelerationM_0 // ( stockage a t=0)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gamma0(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_0(..." ;
Sortie(1);
};
return *gamma0;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_0 (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gamma0(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_0(..." ;
Sortie(1);
};
return *gamma0;
};
// idem à t
const Coordonnee & Met_abstraite::AccelerationM_t // ( stockage a t=t)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gammat(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_t(..." ;
Sortie(1);
};
return *gammat;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_t (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gammat(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_t(..." ;
Sortie(1);
};
return *gammat;
};
// idem à tdt
const Coordonnee & Met_abstraite::AccelerationM_tdt // ( stockage a tdt)
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi)
{ if (tab_noeud(1)->Existe_ici(GAMMA1))
{ Calcul_gammatdt(tab_noeud,phi,nomb_noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas aux noeuds"
<< "\n Met_abstraite::AccelerationM_tdt(..." ;
Sortie(1);
};
return *gammatdt;
};
// idem mais au noeud passé en paramètre
const Coordonnee & Met_abstraite::AccelerationM_tdt (const Noeud* noeud)
{ if (noeud->Existe_ici(GAMMA1)) { Calcul_gammatdt(noeud); }
else
{ cout << "\n erreur l'acceleration n'existe pas au noeud"
<< "\n Met_abstraite::AccelerationM_tdt(..." ;
Sortie(1);
};
return *gammatdt;
};
// calcul de la base naturel ( stockage a t=0) au point correspondant au dphi
const BaseB& Met_abstraite::BaseNat_0 // en fonction des coordonnees a t=0
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi)

157
Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc
View file

@ -876,6 +876,14 @@ double Met_abstraite::DonneeInterpoleeScalaire
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi,int nombre_noeud
,Enum_ddl enu,Enum_dure temps) const
{ double resultat=0.;
#ifdef MISE_AU_POINT
if (!(tab_noeud(1)->Existe_ici(enu)))
{cout << "\n\n *** erreur, la grandeur " << Nom_ddl(enu)
<< " n'existe pas aux noeuds on ne peut pas l'interpoler ";
Sortie(1);
};
#endif
switch (temps)
{ case TEMPS_0:
{ for (int r=1;r<=nombre_noeud;r++)
@ -1380,3 +1388,152 @@ void Met_abstraite::Calcul_d_V_moytdt(const Noeud* )
};
//--- cas des accélérations
// calcul de l'accélération du point a t0 en fonction des ddl existants d'accélération
void Met_abstraite::Calcul_gamma0
( const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (gamma0 == NULL)
{ cout << "\nErreur : l'acceleration au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gamma0 \n";
Sortie(1);
};
if (!(tab_noeud(1)->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gamma0(..)";
Sortie(1);
};
#endif
int amax = gamma0->Dimension();
gamma0->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(gamma0))(3) += tab_noeud(r)->Valeur_0(GAMMA3) * phi(r) ;
case 2: (*(gamma0))(2) += tab_noeud(r)->Valeur_0(GAMMA2) * phi(r) ;
case 1: (*(gamma0))(1) += tab_noeud(r)->Valeur_0(GAMMA1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_gamma0 (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (gamma0 == NULL)
{ cout << "\nErreur : l'acceleration au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gamma0(const Noeud* )\n";
Sortie(1);
};
if (!(noeud->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gamma0(..)";
Sortie(1);
};
#endif
int amax = gamma0->Dimension(); gamma0->Zero();
switch (amax)
{case 3: (*(gamma0))(3) += noeud->Valeur_0(GAMMA3) ;
case 2: (*(gamma0))(2) += noeud->Valeur_0(GAMMA2) ;
case 1: (*(gamma0))(1) += noeud->Valeur_0(GAMMA1) ;
};
};
// idem a t
void Met_abstraite::Calcul_gammat
( const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (gammat == NULL)
{ cout << "\nErreur : l'acceleration au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gammat \n";
Sortie(1);
};
if (!(tab_noeud(1)->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gammat(..)";
Sortie(1);
};
#endif
int amax = gammat->Dimension();
gammat->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(gammat))(3) += tab_noeud(r)->Valeur_t(GAMMA3) * phi(r) ;
case 2: (*(gammat))(2) += tab_noeud(r)->Valeur_t(GAMMA2) * phi(r) ;
case 1: (*(gammat))(1) += tab_noeud(r)->Valeur_t(GAMMA1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_gammat (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (gammat == NULL)
{ cout << "\nErreur : l'acceleration au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gammat(const Noeud* )\n";
Sortie(1);
};
if (!(noeud->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gamma0(..)";
Sortie(1);
};
#endif
int amax = gammat->Dimension(); gammat->Zero();
switch (amax)
{case 3: (*(gammat))(3) += noeud->Valeur_t(GAMMA3) ;
case 2: (*(gammat))(2) += noeud->Valeur_t(GAMMA2) ;
case 1: (*(gammat))(1) += noeud->Valeur_t(GAMMA1) ;
};
};
// idem à tdt
void Met_abstraite::Calcul_gammatdt
( const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (gammatdt == NULL)
{ cout << "\nErreur : l'acceleration au point a tdt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gammatdt \n";
Sortie(1);
};
if (!(tab_noeud(1)->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gammatdt(..)";
Sortie(1);
};
#endif
int amax = gammatdt->Dimension();
gammatdt->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(gammatdt))(3) += tab_noeud(r)->Valeur_tdt(GAMMA3) * phi(r) ;
case 2: (*(gammatdt))(2) += tab_noeud(r)->Valeur_tdt(GAMMA2) * phi(r) ;
case 1: (*(gammatdt))(1) += tab_noeud(r)->Valeur_tdt(GAMMA1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_gammatdt (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (gammatdt == NULL)
{ cout << "\nErreur : l'acceleration au point a tdt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_gammatdt(const Noeud* )\n";
Sortie(1);
};
if (!(noeud->Existe_ici(GAMMA1)))
{cout << "\n *** erreur l'acceleration nest pas definie aux noeuds !! "
<< "\n Met_abstraite::Calcul_gamma0(..)";
Sortie(1);
};
#endif
int amax = gammatdt->Dimension(); gammatdt->Zero();
switch (amax)
{case 3: (*(gammatdt))(3) += noeud->Valeur_tdt(GAMMA3) ;
case 2: (*(gammatdt))(2) += noeud->Valeur_tdt(GAMMA2) ;
case 1: (*(gammatdt))(1) += noeud->Valeur_tdt(GAMMA1) ;
};
};

5
Elements/Mecanique/ElemMeca.cc
View file

@ -2127,6 +2127,11 @@ Element::ResRaid ElemMeca::SMR_charge_pres_I(DdlElement & ddlS,int nSurf
// pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer
(absolue,TEMPS_tdt,li_quelc,defS,ex_impli,ex_expli_tdt,ex_expli);
// //---debug
// cout << "\n debug ElemMeca::SMR_charge_pres_I ";
// cout << li_quelc ;
// //-- fin debug
//
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_val = pt_fonct->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
// if (pt_fonct->Depend_M())

5
Elements/Mecanique/ElemMeca.h
View file

@ -249,7 +249,10 @@ class ElemMeca : public Element
// casMass_relax: permet de choisir entre différentes méthodes de calcul de la masse
void CalculMatriceMassePourRelaxationDynamique
(const double& alph, const double& beta, const double & lambda
,const double & gamma,const double & theta, int casMass_relax);
,const double & gamma,const double & theta, int casMass_relax);
// active les conteneurs d'accélérations si besoin au niveau de la métrique de l'élément
void Active_conteneurs_metrique_acceleration();
// ---------- informations annexes ----------------

25
Elements/Mecanique/ElemMeca2.cc
View file

@ -1088,7 +1088,16 @@ void ElemMeca::CalculMatriceMassePourRelaxationDynamique
}; //-- fin du switch
};
// METHODES VIRTUELLES:
// active les conteneurs d'accélérations si besoin au niveau de la métrique de l'élément
void ElemMeca::Active_conteneurs_metrique_acceleration()
{ if (!(met->Existe_conteneur_acceleration()))
{ Tableau<Enum_variable_metrique> tab(3);
tab(1) = igamma0; tab(2) = igammat; tab(3) = igammatdt;
met->PlusInitVariables(tab) ;
};
};
// METHODES VIRTUELLES:
// recuperation des coordonnées du point de numéro d'ordre = iteg pour
@ -1701,6 +1710,7 @@ void ElemMeca::Valeurs_Tensorielles_interpoler_ou_calculer
Coordonnee* N_surf_t = NULL; // coordonnée d'un vecteur normal à t si c'est adéquate
Coordonnee* N_surf_t0 = NULL; // coordonnée d'un vecteur normal à t0 si c'est adéquate
Coordonnee* Vitesse = NULL; // cas des vitesses
Coordonnee* Acceleration = NULL; // cas des accélérations
Coordonnee* Deplacement = NULL; // cas du déplacement
// pour les valeurs propres
@ -1775,9 +1785,9 @@ void ElemMeca::Valeurs_Tensorielles_interpoler_ou_calculer
Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Vitesse = gr.ConteneurCoordonnee(); break;}
case ACCELERATION:{
Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Vitesse = gr.ConteneurCoordonnee(); break;}
Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Acceleration = gr.ConteneurCoordonnee();
break;}
// dans le cas des numéros, traitement direct ici
case NUM_ELEMENT:
{ *((Grandeur_scalaire_entier*) ((*ipq).Grandeur_pointee()))= num_elt; break;}
@ -1921,6 +1931,13 @@ void ElemMeca::Valeurs_Tensorielles_interpoler_ou_calculer
(*Deplacement) = (*Mtdt) - defor.Position_0();
if (Vitesse != NULL)
(*Vitesse) = defor.VitesseM_tdt();
if (Acceleration != NULL)
// switch (dim_espace)
// { case 3: (*Acceleration) = defor.DonneeInterpoleeScalaire(GAMMA3,temps);
// case 2: (*Acceleration) = defor.DonneeInterpoleeScalaire(GAMMA2,temps);
// case 1: (*Acceleration) = defor.DonneeInterpoleeScalaire(GAMMA1,temps);
// };
(*Acceleration) = defor.AccelerationM_tdt();
// --- cas des grandeurs de la décomposition polaire

6
Enumeration/Enum_variable_metrique.cc
View file

@ -65,6 +65,9 @@ string Nom_Enum_variable_metrique (Enum_variable_metrique id_nom)
case idVt :result="idVt";break;
case iVtdt :result="iVtdt";break;
case idVtdt :result="idVtdt";break;
case igamma0 :result="igamma0";break;
case igammat :result="igammat";break;
case igammatdt :result="igammatdt";break;
case igiB_0 :result="igiB_0";break;
case igiB_t :result="igiB_t";break;
case igiB_tdt :result="igiB_tdt";break;
@ -120,6 +123,9 @@ Enum_variable_metrique Id_nom_Enum_variable_metrique (char* nom)
else if ( strcmp(nom,"idVt")==0 ) result=idVt;
else if ( strcmp(nom,"iVtdt")==0 ) result=iVtdt;
else if ( strcmp(nom,"idVtdt")==0 ) result=idVtdt;
else if ( strcmp(nom,"igamma0")==0 ) result=igamma0;
else if ( strcmp(nom,"igammat")==0 ) result=igammat;
else if ( strcmp(nom,"igammatdt")==0 ) result=igammatdt;
else if ( strcmp(nom,"igiB_0")==0 ) result=igiB_0;
else if ( strcmp(nom,"igiB_t")==0 ) result=igiB_t;
else if ( strcmp(nom,"igiB_tdt")==0 ) result=igiB_tdt;

25
Enumeration/Enum_variable_metrique.h
View file

@ -54,14 +54,15 @@ using namespace std;
/// Définition de l'enuméré concernant les grandeurs gérées par les classes métriques générales
enum Enum_variable_metrique { iM0 =1, iMt, idMt, iMtdt, idMtdt, iV0, iVt, idVt, iVtdt, idVtdt
, igiB_0 , igiB_t, igiB_tdt,
igiH_0, igiH_t, igiH_tdt, igijBB_0, igijBB_t, igijBB_tdt, igijHH_0, igijHH_t,
igijHH_tdt, id_giB_t, id_giB_tdt,
id_giH_t, id_giH_tdt, id_gijBB_t, id_gijBB_tdt, id_gijHH_t, id_gijHH_tdt,
id_jacobien_t , id_jacobien_tdt
, id2_gijBB_tdt // variation seconde de la déformation
,igradVmoyBB_t,igradVmoyBB_tdt,igradVBB_t,igradVBB_tdt // gradient de vitesse moyen et instantannée
,id_gradVmoyBB_t,id_gradVmoyBB_tdt,id_gradVBB_t,id_gradVBB_tdt // variation du gradient de vitesse
,igamma0,igammat,igammatdt
, igiB_0 , igiB_t, igiB_tdt,
igiH_0, igiH_t, igiH_tdt, igijBB_0, igijBB_t, igijBB_tdt, igijHH_0, igijHH_t,
igijHH_tdt, id_giB_t, id_giB_tdt,
id_giH_t, id_giH_tdt, id_gijBB_t, id_gijBB_tdt, id_gijHH_t, id_gijHH_tdt,
id_jacobien_t , id_jacobien_tdt
, id2_gijBB_tdt // variation seconde de la déformation
,igradVmoyBB_t,igradVmoyBB_tdt,igradVBB_t,igradVBB_tdt // gradient de vitesse moyen et instantannée
,id_gradVmoyBB_t,id_gradVmoyBB_tdt,id_gradVBB_t,id_gradVBB_tdt // variation du gradient de vitesse
};
/// @} // end of group
@ -72,10 +73,10 @@ enum Enum_variable_metrique { iM0 =1, iMt, idMt, iMtdt, idMtdt, iV0, iVt, idVt,
enum Enum_variable_metsfe { iP0 =1, iPt, idPt, iPtdt, idPtdt
, iaiB_0 , iaiB_t, iaiB_tdt,
iaiH_0, iaiH_t, iaiH_tdt, iaijBB_0, iaijBB_t, iaijBB_tdt, iaijHH_0, iaijHH_t,
iaijHH_tdt, id_aiB_t, id_aiB_tdt,
id_aiH_t, id_aiH_tdt, id_aijBB_t, id_aijBB_tdt, id_aijHH_t, id_aijHH_tdt,
id_ajacobien_t , id_ajacobien_tdt
iaiH_0, iaiH_t, iaiH_tdt, iaijBB_0, iaijBB_t, iaijBB_tdt, iaijHH_0, iaijHH_t,
iaijHH_tdt, id_aiB_t, id_aiB_tdt,
id_aiH_t, id_aiH_tdt, id_aijBB_t, id_aijBB_tdt, id_aijHH_t, id_aijHH_tdt,
id_ajacobien_t , id_ajacobien_tdt
};
/// @} // end of group

15
Maillage/LesMaillages2.cc
View file

@ -102,8 +102,19 @@ void LesMaillages::Plus_Les_ddl_Acceleration(Enum_boolddl val_fixe)
if (noo->Existe_ici(X1))
noo->PlusTabDdl(ta);
}
}
};
}
// on va passer en revue les éléments pour initialiser si nécessaire les conteneurs
// d'accélération si on est en mécanique
// on balaie les maillages et les éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Active_conteneurs_metrique_acceleration();
};
};
};
// calcul de la longueur d'arrête d'élément minimal
// divisé par la célérité dans le matériau

2
Parametres/EnteteParaGlob.h
View file

@ -41,7 +41,7 @@
EnumLangue ParaGlob::langueHZ = FRANCAIS; // langue utilisée pour les entrées sorties
int ParaGlob::nbComposantesTenseur = 1; // nombre de composantes par defaut a 1
int ParaGlob::nivImpression = 2; // niveau d'impression
string ParaGlob::nbVersion = "7.011" ; // numéro de version du logiciel
string ParaGlob::nbVersion = "7.012" ; // numéro de version du logiciel
string ParaGlob::NbVersionsurfichier = ""; // numéro de version lue en entrée fichier
int ParaGlob::nb_diggit_double_calcul= 17; // nombre de chiffre significatifs utilisé pour
// l'affichage des double précision pour l'archivage

146
Util/Courbes/Fonction_nD.cc
View file

@ -716,6 +716,9 @@ void Fonction_nD::Construction_index_conteneurs_evoluees()
list <EnumTypeQuelconque> li_inter_tyQ; // idem
list <int> li_index_quelc;
// def d'une liste qui permettra ensuite de construire tab_equi_Coor et tab_equi_tens
list <List_io <TypeQuelconque >::iterator > li_tab_equi;
// un conteneur de service: un réel par ddl
Ddl_enum_etendu ddl_de_service;
list <double> list_inter_val_ddl_enum; // inter qui donnera ensuite: val_ddl_enum
@ -773,11 +776,27 @@ void Fonction_nD::Construction_index_conteneurs_evoluees()
if (!(Ddl_enum_etendu::Existe_dans_la_liste(li_premier_famille_Coord,Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service))))
// s'il n'existe pas on rajoute le premier de la famille
{ Coordonnee pt_coor(dim);
// //--- debug
// if (permet_affichage > 9)
// {cout << "\n debug Fonction_nD::Construction_index_conteneurs_evoluees() "
// << "\n mise en place de coordonnees arbitraire pour " ;
// pt_coor(1)=i*10+1.; pt_coor(2) = i*10+2.;pt_coor(3) = i*10+4.;
// cout << "\n grandeur= "<<nom_variables(i);
// };
// //-- fin debug
li_coor_ddl_enum.push_back(pt_coor);
li_premier_famille_Coord.push_back(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service));
// on s'occupe de la grandeur quelconque équivalente
EnumTypeQuelconque enuQ = Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(ddl_de_service);
TypeQuelconque typQ6(enuQ,ddl_de_service.Enum(),grand5);
// //--- debug
// if (permet_affichage > 9)
// {cout << "\n debug Fonction_nD::Construction_index_conteneurs_evoluees() ";
// Grandeur_coordonnee& coo = *((Grandeur_coordonnee*) typQ6.Grandeur_pointee());
// *(coo.ConteneurCoordonnee()) = pt_coor;
// cout << "\n idem pour le conteneur quelconque ";
// }
li_equi_Quel_evolue.push_back(typQ6);
};
// // maintenant il faut récupérer la position = l'indice, de l'enu dans Coordonnee
@ -933,6 +952,45 @@ void Fonction_nD::Construction_index_conteneurs_evoluees()
};
delete tens; // car on n'en a plus besoin
// //--- debug
// if (permet_affichage > 9)
// {cout << "\n debug Fonction_nD::Construction_index_conteneurs_evoluees() ";
// List_io <TypeQuelconque >::iterator i_evol = li_equi_Quel_evolue.begin();
// int nb_enu = index_enu_etendu.Taille();
// // qui a la même taille que tab_enu_etendu, et dans le même ordre
// for (int ienu=1;ienu <= nb_enu; ienu++)
// {int num_variable = index_enu_etendu(ienu); // le numéro de nom_variable
// switch (type_des_variables(num_variable))
// { case 2: // Coordonnee
// {int j = posi_ddl_enum(ienu);
// // pour simplifier l'écriture
// List_io<TypeQuelconque >::iterator& il = tab_equi_Coor(j);
// Grandeur_coordonnee& coo = *((Grandeur_coordonnee*) (*il).Grandeur_pointee());
// Coordonnee& coord = *(coo.ConteneurCoordonnee());
// double valeur = coord(num_dans_coor(ienu));
// cout << "\n version type quelconque :";
// cout << "\n Coordonnee: num_variable= "<<num_variable
// << " di (num_variable)= "<<valeur
// << " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
// << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
// << "\n coord= "<<coord ;
//
// cout << "\n version tableau de coordonnées :";
// cout << "\n Coordonnee: num_variable= "<<num_variable
// << " di (num_variable)= "<<coor_ddl_enum(j)(num_dans_coor(ienu))
// << " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
// << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
// << "\n coord= "<<coor_ddl_enum(j) ;
// i_evol++;
// break;}
// default:
// break;
// };
// }; // fin de la boucle sur les enum
// Sortie(1);
// };
// //-- fin debug
// on met à jour le tableau de transfert
// ici par défaut chaque type quelconque est associé à un conteneur scalaire
@ -953,6 +1011,7 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
,const Tableau <int> * t_num_ordre)
{
#ifdef MISE_AU_POINT
{
if (di.Taille() != (tab_enu_etendu.Taille() + tab_enu_quelconque.Taille()))
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " tab_enu_etendu.Taille()= " << tab_enu_etendu.Taille()
@ -1021,6 +1080,12 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
};
};
};
}
#endif
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n\n detail pour Fonction_nD::Vers_tab_double( AVEC DES TABLEAUX : FCT= " << nom_ref
<< "\n les variables: "<< nom_variables;
#endif
// on va boucler sur les arguments:
// on utilise les index, pour un adressage indirect, pour le tableau de retour "et"
@ -1032,15 +1097,37 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
switch (type_des_variables(num_variable))
{ case 1: // scalaire
{di(num_variable) = val_ddl_enum->operator()(posi_ddl_enum(ienu));
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n scalaire: num_variable= "<<num_variable
<< " di(num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu);
#endif
break;}
case 2: // Coordonnee
{int j = posi_ddl_enum(ienu);
di(num_variable) = (*coor_ddl_enum)(j)(num_dans_coor(ienu));
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n Coordonnee: num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
<< " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
<< "\n coord= "<<(*coor_ddl_enum)(j) ;
#endif
break;}
case 3: // tenseur
{int j = posi_ddl_enum(ienu);
int k = ind_tens(ienu).i; int l = ind_tens(ienu).j;
di(num_variable) = (*(*tens_ddl_enum)(j))(k,l);
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
<< " indices dans tenseur: (k,l)= ("<<k<<","<<l<<")"
<< "\n tensBB= ";(*tens_ddl_enum)(j)->Ecriture(cout) ;
#endif
break;}
default:
break;
@ -1054,6 +1141,13 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
if (t_num_ordre != NULL)
nb_ordre = (*t_num_ordre)(ieq);
di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " nb_ordre= "<<nb_ordre
<< "\n grandeur: " << (*tqi)(ieq)->Const_Grandeur_pointee();
#endif
}; // fin de la boucle sur les enu quelconques
// retour
@ -1070,6 +1164,7 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
,const Tableau <int> * t_num_ordre)
{
#ifdef MISE_AU_POINT
{
// on vérifie qu'il s'agit bien des mêmes listes
if ((&li_enu_etendu_scalaire) != li_evolue_scalaire)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
@ -1125,6 +1220,7 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
};
};
};
}
#endif
// on va boucler sur les arguments:
@ -1132,12 +1228,15 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
List_io <TypeQuelconque >::iterator i_evol = li_equi_Quel_evolue.begin();
int indice_scal=1; // init : indice dans le tableau val_ddl_enum
////------- debug
//cout << "\n\n debug Fonction_nD::Vers_tab_double( : FCT= " << nom_ref
// << "\n les variables: "<< nom_variables
// << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
// << " num_dans_coor= "<<num_dans_coor;
////------- fin debug
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
{cout << "\n\n detail pour Fonction_nD::Vers_tab_double( AVEC DES LISTES : FCT= " << nom_ref
<< "\n les variables: "<< nom_variables;
cout << "\n li_evoluee_non_scalaire ";
cout << *li_evoluee_non_scalaire ;
};
//-- fin debug
#endif
// 1) sur les enum
int nb_enu = index_enu_etendu.Taille();
// qui a la même taille que tab_enu_etendu, et dans le même ordre
@ -1146,6 +1245,12 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
switch (type_des_variables(num_variable))
{ case 1: // scalaire
{di(num_variable) = (*val_ddl_enum)(posi_ddl_enum(ienu));
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n scalaire: num_variable= "<<num_variable
<< " di(num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu);
#endif
break;}
case 2: // Coordonnee
{int j = posi_ddl_enum(ienu);
@ -1154,12 +1259,14 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
Grandeur_coordonnee& coo = *((Grandeur_coordonnee*) (*il).Grandeur_pointee());
Coordonnee& coord = *(coo.ConteneurCoordonnee());
di(num_variable) = coord(num_dans_coor(ienu));
////------- debug
//cout << "\n num_variable= "<<num_variable
// << " di (num_variable)= "<<di(num_variable)
// << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
// << "\n coord= "<<coord ;
////------- fin debug
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n Coordonnee: num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
<< " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
<< "\n coord= "<<coord ;
#endif
i_evol++;
break;}
case 3: // tenseur
@ -1170,6 +1277,14 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
Grandeur_TenseurBB& ten = *((Grandeur_TenseurBB*) (*il).Grandeur_pointee());
TenseurBB& tensBB = ten.RefConteneurTenseur();
di(num_variable) = tensBB(k,l);
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
<< " indices dans tenseur: (k,l)= ("<<k<<","<<l<<")"
<< "\n tensBB= ";tensBB.Ecriture(cout) ;
#endif
i_evol++;
break;}
default:
@ -1185,6 +1300,13 @@ Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
if (t_num_ordre != NULL)
nb_ordre = (*t_num_ordre)(ieq);
di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
#ifdef MISE_AU_POINT
if (permet_affichage > 9)
cout << "\n num_variable= "<<num_variable
<< " di (num_variable)= "<<di(num_variable)
<< " nb_ordre= "<<nb_ordre
<< "\n grandeur: " << (*tqi)(ieq)->Const_Grandeur_pointee();
#endif
}; // fin de la boucle sur les enu quelconques
////------ debug