Herezh++

Gérard,

suite discussion, j'ai testé une loi de mélange type_melange= 2. Les résultats étaient assez étonnants. Donc pour comprendre, je suis reparti d'une version très simple.

en pièce jointe, calcul de traction sur un cube avec au choix un mélange de 2 lois HYPOELAS ou 2 lois ISOELAS.

Sur un intervalle de temps de 0 à 1, la fonction mélange est : 1. - 0.6*temps. Donc le mélange passe de 100% la loi 1 à t=0 à une proportion 40%-60% à t=1.

J'ai écrit 2 programmes python sensés reproduire le calcul Herezh pour ces 2 cas (inclus dans l'archive jointe). Ils lisent le résultat hz++ .maple, exploitent les valeurs de EPS pour calculer la contrainte 11 et afficher dans le terminal 4 colonnes :
temps - contrainte SIG11 herezh++ - contrainte SIG11 "méthode 1" - contrainte SIG22 "méthode 2"

J'entends par "méthode 1 ou 2" les cas suivants :
méthode 1) :
contrainte calculée selon la formule indiquée dans la doc hz++. Normalement ça devrait être à peu près la formule (89) page 280 de la doc : sigma_finale_t+dt = sigma_loi_1_t + sigma_loi_2_t + mélange incréments

j'ai tenté le calcul suivant pour chaque loi :
1) SIG_t => calcul de la loi à t
2) INCREMENT => calcul de l'incrément entre t et t+dt
3) INCREMENT_propor => application de la proportion : alpha*INCREMENT (ou (1-alpha) si loi 2)
4) ajout de " SIG_t + INCREMENT_propor " à la contrainte mélange

c'est très certainement pas le bon calcul car la proportion n'est pas appliqué à SIG_t

donc autre tentative avec méthode 2

méthode 2) :
j'ai regardé le fichier source .cc de la loi de mélange. Je crois comprendre que le "type_melange= 2" est traité à la ligne 1918 du fichier :

else  // cas == 2
             { (*deltaSigHH) = sigHH - (*(*isig_t)); (*deltaSigHH) *= facteur_multiplicatif;
               (*(*jsig))=(*(*jsig_t)) + (*deltaSigHH); // on sauvegarde la contrainte partielle proportionalisée
               (*sigtotalHH) += (*(*jsig)); // cumule
             };

ce code me donne l'impression que dans hz++, le calcul serait le suivant :
sigma_finale_t+dt = sigma_loi_1_t+dt + sigma_loi_2_t+dt
où sigma_loi_1_t+dt et sigma_loi_2_t+dt serait l'accumulation des lois en tenant compte de la proportion de mélange

dans mon prog python, je fais pour chaque loi :
1) SIG_t => calcul de la loi à t
2) SIG_t_dt => calcul de la loi à t+dt
3) INCREMENT => différence entre SIG_t_dt et SIG_t
4) INCREMENT_propor => application de la proportion : alpha*INCREMENT (ou (1-alpha) si loi 2)
5) ajout de INCREMENT_propor à la contrainte mélange (qui accumule ainsi les incréments avec proportion)

NB : ce n'est pas exactement écrit comme ça dans mes programmes, mais dans l'idée c'est ça.

Au final, aucun de mes calculs ne donne le résultat fourni par Herezh.

Par exemple, si on prend le mélange MAT_ISOELAS des 2 lois suivantes :
loi 1 => ISOELAS E=100, NU=0.3
loi 2 => ISOELAS E=200, NU=0.45

le programme python verif_th_ISOELAS.py donne :

#[1]temps  [2]SIG11 hz++  [3]SIG11 python v1  [4]SIG11 python v2
0.01 0.9946254710068 0.9946254710068124 0.9946254710068124
.
. etc...
.
0.98 24.04093313668 137.19963493212614 45.06712401751332
0.99 23.71666775864 137.56469461065063 45.261879036196376
1.0 23.38314309983 137.9236398880391 45.4542492662177

donc, soit une méthode 1 (v1) largement au-dessus, ou une méthode 2 (v2) un peu plus proche mais pas bon non plus