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

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

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( ";

Elements/Mecanique/Deformation_gene/Deformation.h

@@ -487,6 +487,21 @@ class  Deformation
    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
    // à cette base particulière que l'on va appeler IPa

Elements/Mecanique/Deformation_gene/Met_abstraite.h

@@ -367,6 +367,32 @@ class Met_abstraite
      // 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);
@@ -485,6 +511,23 @@ class Met_abstraite
     // 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
     // calcul de la base naturel a t0
@@ -614,6 +657,10 @@ class Met_abstraite
 	   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é
                
+    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

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,6 +97,7 @@ 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;
@@ -203,6 +205,12 @@ 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,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) ) 
@@ -410,6 +418,7 @@ 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;
+        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;
@@ -439,6 +448,9 @@ void Met_abstraite::Allocation ()
 	       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,6 +647,17 @@ 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.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;}}

Elements/Mecanique/Deformation_gene/Met_abstraite2s2.cc

@@ -712,6 +712,78 @@ const Tableau<Coordonnee> & Met_abstraite::D_VitesseM_tdt(const Noeud* noeud,boo
     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)

Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc

@@ -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) ;
+    };
+ };
+
+

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 <double> & tab_val = pt_fonct->Valeur_FnD_Evoluee(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
 //          if (pt_fonct->Depend_M())

Elements/Mecanique/ElemMeca.h

@@ -251,6 +251,9 @@ class   ElemMeca : public Element
                      (const double& alph, const double& beta, const double & lambda
                      ,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  ----------------
 
        // récupération de la base locales au noeud noe, pour le temps: temps 

Elements/Mecanique/ElemMeca2.cc

@@ -1088,6 +1088,15 @@ void  ElemMeca::CalculMatriceMassePourRelaxationDynamique
 	     }; //-- fin du switch
 	};  
             
+// 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:
         
 
@@ -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
@@ -1776,8 +1786,8 @@ void ElemMeca::Valeurs_Tensorielles_interpoler_ou_calculer
          Vitesse = gr.ConteneurCoordonnee();  break;}
        case ACCELERATION:{
          Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
-           Vitesse = gr.ConteneurCoordonnee();  break;}
+         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
 

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;

Enumeration/Enum_variable_metrique.h

@@ -54,6 +54,7 @@ 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
+            ,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,

Maillage/LesMaillages2.cc

@@ -103,7 +103,18 @@ void LesMaillages::Plus_Les_ddl_Acceleration(Enum_boolddl val_fixe)
             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

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

Util/Courbes/Fonction_nD.cc

@@ -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
@@ -934,6 +953,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
     // si ce n'est pas le cas, on considère que l'utilisateur utilisera la méthode
@@ -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
+    #ifdef MISE_AU_POINT
-//cout << "\n\n debug Fonction_nD::Vers_tab_double( : FCT= " << nom_ref
+    if (permet_affichage > 9)
-//     << "\n les variables: "<< nom_variables
+      {cout << "\n\n detail pour Fonction_nD::Vers_tab_double( AVEC DES LISTES  : FCT= " << nom_ref
-//     << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
+           << "\n les variables: "<< nom_variables;
-//     << " num_dans_coor= "<<num_dans_coor;
+       cout << "\n li_evoluee_non_scalaire ";
-////------- fin debug
+       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
+             #ifdef MISE_AU_POINT
-//cout << "\n num_variable= "<<num_variable
+             if (permet_affichage > 9)
-//     << " di (num_variable)= "<<di(num_variable)
+               cout << "\n Coordonnee: num_variable= "<<num_variable
-//     << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
+                    << " di (num_variable)= "<<di(num_variable)
-//     << "\n coord= "<<coord ;
+                    << " posi_ddl_enum(ienu)= "<<posi_ddl_enum(ienu)
-////------- fin debug
+                    << " 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