From ece68c42db8d60f179763383b77455185da8266d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9rard=20Rio?= Date: Thu, 1 Jun 2023 08:47:54 +0200 Subject: [PATCH] =?UTF-8?q?V=207.012=20:=20r=C3=A9solution=20du=20pb=20de?= =?UTF-8?q?=20l'utilisation=20de=20l'acc=C3=A9l=C3=A9ration=20dans=20une?= =?UTF-8?q?=20fonction=20nD=20Introduction=20du=20calcul=20de=20l'acc?= =?UTF-8?q?=C3=A9l=C3=A9ration=20interpol=C3=A9e,=20au=20niveau=20de=20la?= =?UTF-8?q?=20m=C3=A9trique=20Intro=20de=20nouveaux=20affichages=20au=20ni?= =?UTF-8?q?veau=20des=20fonctions=20nD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Mecanique/Deformation_gene/Deformation.cc | 2 + .../Mecanique/Deformation_gene/Deformation.h | 15 ++ .../Deformation_gene/Met_abstraite.h | 51 +++++- .../Deformation_gene/Met_abstraite1s2.cc | 96 +++++++---- .../Deformation_gene/Met_abstraite2s2.cc | 74 ++++++++- .../Deformation_gene/Met_abstraite3s2.cc | 157 ++++++++++++++++++ Elements/Mecanique/ElemMeca.cc | 5 + Elements/Mecanique/ElemMeca.h | 5 +- Elements/Mecanique/ElemMeca2.cc | 25 ++- Enumeration/Enum_variable_metrique.cc | 6 + Enumeration/Enum_variable_metrique.h | 25 +-- Maillage/LesMaillages2.cc | 15 +- Parametres/EnteteParaGlob.h | 2 +- Util/Courbes/Fonction_nD.cc | 146 ++++++++++++++-- 14 files changed, 554 insertions(+), 70 deletions(-) diff --git a/Elements/Mecanique/Deformation_gene/Deformation.cc b/Elements/Mecanique/Deformation_gene/Deformation.cc index d34924b..e8d2eab 100644 --- a/Elements/Mecanique/Deformation_gene/Deformation.cc +++ b/Elements/Mecanique/Deformation_gene/Deformation.cc @@ -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( "; diff --git a/Elements/Mecanique/Deformation_gene/Deformation.h b/Elements/Mecanique/Deformation_gene/Deformation.h index 9b32864..1d00bc3 100644 --- a/Elements/Mecanique/Deformation_gene/Deformation.h +++ b/Elements/Mecanique/Deformation_gene/Deformation.h @@ -486,6 +486,21 @@ class Deformation {return metrique->D_VitesseM_tdt((*tabnoeud)(num_noeud),ddl_vitesse);}; virtual const Tableau & 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 diff --git a/Elements/Mecanique/Deformation_gene/Met_abstraite.h b/Elements/Mecanique/Deformation_gene/Met_abstraite.h index 6c869b9..3e24a29 100644 --- a/Elements/Mecanique/Deformation_gene/Met_abstraite.h +++ b/Elements/Mecanique/Deformation_gene/Met_abstraite.h @@ -366,7 +366,33 @@ class Met_abstraite (const Tableau& tab_noeud,const Vecteur& phi,bool ddl_vitesse); // idem mais au noeud passé en paramètre virtual const Tableau & 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& 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& 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& 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& tab_noeud,const Mat_pleine& tabDphi,const Vecteur& phi); @@ -484,6 +510,23 @@ class Met_abstraite (const Tableau& 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& 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& 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& 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 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 diff --git a/Elements/Mecanique/Deformation_gene/Met_abstraite1s2.cc b/Elements/Mecanique/Deformation_gene/Met_abstraite1s2.cc index bf95d52..c69ed31 100644 --- a/Elements/Mecanique/Deformation_gene/Met_abstraite1s2.cc +++ b/Elements/Mecanique/Deformation_gene/Met_abstraite1s2.cc @@ -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 (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& 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 (nbddl_x,toto);} - if (Existe(tab,iMtdt)) Mtdt = new Coordonnee(dim_base); - if (Existe(tab,idMtdt)) - {Coordonnee toto(dim_base); d_Mtdt = new Tableau (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 (nbddl_x,toto);} + if (Existe(tab,iMtdt)) Mtdt = new Coordonnee(dim_base); + if (Existe(tab,idMtdt)) + {Coordonnee toto(dim_base); d_Mtdt = new Tableau (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 (nbddl_x,toto);} if (Existe(tab,iVtdt)) Vtdt = new Coordonnee(dim_base); if (Existe(tab,idVtdt)) {Coordonnee toto(dim_base); d_Vtdt = new Tableau (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& 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 (*(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) diff --git a/Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc b/Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc index fa3f512..a037c35 100644 --- a/Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc +++ b/Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc @@ -711,7 +711,79 @@ const Tableau & 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& 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& 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& 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& tab_noeud, const Mat_pleine& dphi,const Vecteur& phi) diff --git a/Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc b/Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc index 6cb90b9..43d9fa3 100644 --- a/Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc +++ b/Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc @@ -876,6 +876,14 @@ double Met_abstraite::DonneeInterpoleeScalaire (const Tableau& 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& 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& 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& 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) ; + }; + }; + + diff --git a/Elements/Mecanique/ElemMeca.cc b/Elements/Mecanique/ElemMeca.cc index 4bad79e..3564c94 100644 --- a/Elements/Mecanique/ElemMeca.cc +++ b/Elements/Mecanique/ElemMeca.cc @@ -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 & tab_val = pt_fonct->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL); // if (pt_fonct->Depend_M()) diff --git a/Elements/Mecanique/ElemMeca.h b/Elements/Mecanique/ElemMeca.h index 50f6c0b..82a8c6a 100644 --- a/Elements/Mecanique/ElemMeca.h +++ b/Elements/Mecanique/ElemMeca.h @@ -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 ---------------- diff --git a/Elements/Mecanique/ElemMeca2.cc b/Elements/Mecanique/ElemMeca2.cc index 061a5f6..6efc81f 100644 --- a/Elements/Mecanique/ElemMeca2.cc +++ b/Elements/Mecanique/ElemMeca2.cc @@ -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 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 diff --git a/Enumeration/Enum_variable_metrique.cc b/Enumeration/Enum_variable_metrique.cc index ec55e05..a56a6f8 100644 --- a/Enumeration/Enum_variable_metrique.cc +++ b/Enumeration/Enum_variable_metrique.cc @@ -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; diff --git a/Enumeration/Enum_variable_metrique.h b/Enumeration/Enum_variable_metrique.h index 1741fed..96106ec 100644 --- a/Enumeration/Enum_variable_metrique.h +++ b/Enumeration/Enum_variable_metrique.h @@ -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 diff --git a/Maillage/LesMaillages2.cc b/Maillage/LesMaillages2.cc index 44d22ce..7c02de4 100644 --- a/Maillage/LesMaillages2.cc +++ b/Maillage/LesMaillages2.cc @@ -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 diff --git a/Parametres/EnteteParaGlob.h b/Parametres/EnteteParaGlob.h index cc1096e..0a9f603 100644 --- a/Parametres/EnteteParaGlob.h +++ b/Parametres/EnteteParaGlob.h @@ -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 diff --git a/Util/Courbes/Fonction_nD.cc b/Util/Courbes/Fonction_nD.cc index 38ced76..e37ad08 100755 --- a/Util/Courbes/Fonction_nD.cc +++ b/Util/Courbes/Fonction_nD.cc @@ -716,6 +716,9 @@ void Fonction_nD::Construction_index_conteneurs_evoluees() list li_inter_tyQ; // idem list li_index_quelc; + // def d'une liste qui permettra ensuite de construire tab_equi_Coor et tab_equi_tens + list ::iterator > li_tab_equi; + // un conteneur de service: un réel par ddl Ddl_enum_etendu ddl_de_service; list 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= "< 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 ::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::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= "< & Fonction_nD::Vers_tab_double(Tableau & 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= "<Const_Grandeur_pointee(); + #endif }; // fin de la boucle sur les enu quelconques // retour @@ -1070,6 +1164,7 @@ Tableau & Fonction_nD::Vers_tab_double(Tableau & di ,const Tableau * 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 & Fonction_nD::Vers_tab_double(Tableau & di }; }; }; + } #endif // on va boucler sur les arguments: @@ -1132,12 +1228,15 @@ Tableau & Fonction_nD::Vers_tab_double(Tableau & di List_io ::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= "< 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 & Fonction_nD::Vers_tab_double(Tableau & 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= "<Const_Grandeur_pointee(); + #endif }; // fin de la boucle sur les enu quelconques ////------ debug