1206 lines
53 KiB
C++
1206 lines
53 KiB
C++
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
#include "UmatAbaqus.h"
|
|
|
|
#include "NevezTenseur.h"
|
|
#include "NevezTenseurQ.h"
|
|
#include "ParaGlob.h"
|
|
#include "TenseurQ-3.h"
|
|
#include "TenseurQ-2.h"
|
|
#include "Tenseur3.h"
|
|
#include "Tenseur2.h"
|
|
#include "ConstMath.h"
|
|
|
|
// --- fichier pour le tube ------
|
|
#ifdef SYSTEM_MAC_OS_CARBON
|
|
#include <types.h>
|
|
#include <stat.h>
|
|
#else
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <fcntl.h> /* Pour O_WRONLY, etc */
|
|
|
|
#include <unistd.h> // pour les ordres read write close
|
|
|
|
|
|
//------------------------- variables statiques ---------------------------
|
|
|
|
const UmatAbaqus::ChangementIndex UmatAbaqus::cdex;
|
|
|
|
// init de la variable statique cdex: cas 3D
|
|
// fonctionne aussi avec le cas 3D axi, c'est uniquement le terme (1,2) (= (2,1)) qui est
|
|
// non nul
|
|
UmatAbaqus::ChangementIndex::ChangementIndex() :
|
|
idx_i(6),idx_j(6),odVect(3)
|
|
{ idx_i(1)=1;idx_i(2)=2;idx_i(3)=3;idx_i(4)=1;idx_i(5)=1;idx_i(6)=2;
|
|
idx_j(1)=1;idx_j(2)=2;idx_j(3)=3;idx_j(4)=2;idx_j(5)=3;idx_j(6)=3;
|
|
odVect(1,1)=1;odVect(2,1)=4;odVect(3,1)=5;
|
|
odVect(1,2)=4;odVect(2,2)=2;odVect(3,2)=6;
|
|
odVect(1,3)=5;odVect(2,3)=6;odVect(3,3)=3;
|
|
};
|
|
|
|
const UmatAbaqus::ChangementIndexCP UmatAbaqus::cdexCP;
|
|
|
|
// init de la variable statique cdexCP : cas 3D CP
|
|
UmatAbaqus::ChangementIndexCP::ChangementIndexCP() :
|
|
// 11 -> 1 22 -> 2 12 -> 3
|
|
idx_i(3),idx_j(3),odVect(2)
|
|
{ idx_i(1)=1;idx_i(2)=2;idx_i(3)=1;
|
|
idx_j(1)=1;idx_j(2)=2;idx_j(3)=2;
|
|
odVect(1,1)=1;odVect(1,2)=3;odVect(2,2)=2;
|
|
odVect(2,1)=3; // stockage symétrique
|
|
};
|
|
|
|
//---------------------- fin variables statiques ---------------------------
|
|
|
|
// par défaut
|
|
UmatAbaqus::UmatAbaqus(int dimension_espace, int nb_vecteur):
|
|
// si dimension = 2, on ne peut accepter que nb_vecteur = 2
|
|
// donc on prend MiN(dimension_espace,nb_vecteur)
|
|
STRESS(NULL),t_sigma(NevezTenseurHH(MiN(dimension_espace,nb_vecteur)))
|
|
,STATEV(NULL),v_statev()
|
|
,DDSDDE(NULL)
|
|
,d_sigma_deps(NevezTenseurHHHH(MiN(dimension_espace,nb_vecteur)*10+MiN(dimension_espace,nb_vecteur)))
|
|
,SSE(NULL),SPD(NULL),SCD(NULL)
|
|
,energie_elastique(0.),dissipation_plastique(0.),dissipation_visqueuse(0.)
|
|
,RPL(NULL),ener_therm_vol_par_utemps(0.)
|
|
,DDSDDT(NULL)
|
|
,d_sigma_d_tempera(NevezTenseurHH(MiN(dimension_espace,nb_vecteur)))
|
|
,DRPLDE(NULL)
|
|
,d_ener_therm_vol_deps(NevezTenseurHH(MiN(dimension_espace,nb_vecteur)))
|
|
,DRPLDT(NULL),d_ener_therm_dtemper(0.)
|
|
,PNEWDT(NULL),pnewdt(0.)
|
|
,STRAN(NULL)
|
|
,eps_meca(NevezTenseurBB(MiN(dimension_espace,nb_vecteur)))
|
|
,DSTRAN(NULL)
|
|
,delta_eps_meca(NevezTenseurBB(MiN(dimension_espace,nb_vecteur)))
|
|
,TIME(NULL),temps_t(0.),temps_tdt(0.)
|
|
,DTIME(NULL),delta_t(0.)
|
|
,TemP(NULL),temper_t(0.)
|
|
,DTEMP(NULL),delta_temper(0.)
|
|
,PREDEF(NULL),ddlNoeA_ptinteg()
|
|
,DPRED(NULL),delta_ddlNoeA_ptinteg()
|
|
,CMNAME(NULL),nom_materiau()
|
|
,NDI(NULL),dim_tens(0)
|
|
,NSHR(NULL),nb_tau_ij(0)
|
|
,NTENS(NULL),nb_ij_tenseur(0)
|
|
,NSTATV(NULL),nb_variables_etat(0)
|
|
,PROPS(NULL),proprietes_materiau()
|
|
,NPROPS(NULL),nb_proprietes_materiau(0)
|
|
,COORDS(NULL),coor_pt(dimension_espace)
|
|
,DROT(NULL),mat_corota(3,3) // je crois que l'on est obligé d'être toujours en 3x3
|
|
// pour abaqus
|
|
,CELENT(NULL),longueur_characteristique(-1)
|
|
,DFGRD0(NULL)
|
|
,giB_t(dimension_espace,MiN(dimension_espace,nb_vecteur))
|
|
,DFGRD1(NULL)
|
|
,giB_tdt(dimension_espace,MiN(dimension_espace,nb_vecteur))
|
|
,NOEL(NULL),nb_elem(0)
|
|
,NPT(NULL),nb_pt_integ(0)
|
|
,LAYER(NULL),nb_du_plis(0)
|
|
,KSPT(NULL),nb_pt_dans_le_plis(0)
|
|
,KSTEP(NULL),nb_step(0)
|
|
,KINC(NULL),nb_increment(0)
|
|
,passage(0),envoi("Umat_envoi_Hz"),reception("Umat_reception_Hz")
|
|
,N_t(dimension_espace),N_tdt(dimension_espace)
|
|
{
|
|
|
|
|
|
|
|
// on définit les grandeurs pointées au bon endroit dans la chaine de
|
|
// caractères
|
|
// on considère que les int sont codés sur 4 octets, les doubles sur 8
|
|
// On se met dans le cas en 3D (taille maxi) d'où l'ensemble des infos
|
|
// STRESS 6*8=48, STATEV rien on n'en tiend pas compte
|
|
// DDSDDE 36*8= 288, SSE+SPD+SCD 3*8=24
|
|
// RPL 8, DDSDDT 6*8=48, DRPLDE 6*8=48, DRPLDT 8, PNEWDT 8,
|
|
// STRAN 6*8=48, DSTRAN 6*8=48
|
|
// TIME 2*8=16, DTIME 8, TemP 8, DTEMP 8,
|
|
// PREDEF rien on n'en tiens pas compte
|
|
// DPRED rien on n'en tiens pas compte
|
|
// CMNAME 24 (par défaut sur 24 caractères: dans abaqus c'est sur 80)
|
|
// NDI+NSHR+NTENS+NSTATV 4*4=16,
|
|
// PROPS rien on n'en tiens pas compte
|
|
// NPROPS rien on n'en tiens pas compte
|
|
// COORDS 3*8=24, DROT 9*8=72,
|
|
// CELENT 8,
|
|
// DFGRD0 9*8=72, DFGRD1 9*8=72,
|
|
// NOEL+NPT+LAYER+KSPT+KSTEP+KINC 6*4=24
|
|
// total 952 octets
|
|
// --- en sortie uniquement
|
|
DDSDDT = &t_car_x_n.x[0]; // 6
|
|
DRPLDE = &t_car_x_n.x[6]; // 6
|
|
DDSDDE = &t_car_x_n.x[12]; // 36
|
|
// --- en entrée - sortie
|
|
RPL = &t_car_x_n.x[48]; // 1
|
|
STRESS = &t_car_x_n.x[49]; // 6
|
|
SSE = &t_car_x_n.x[55]; // 1
|
|
SPD = &t_car_x_n.x[56]; // 1
|
|
SCD = &t_car_x_n.x[57]; // 1
|
|
DRPLDT = &t_car_x_n.x[58]; // 1
|
|
PNEWDT = &t_car_x_n.x[59]; // 1
|
|
// --- en entrée seulement
|
|
STRAN = &t_car_x_n.x[60]; // 6
|
|
DSTRAN = &t_car_x_n.x[66]; // 6
|
|
TIME = &t_car_x_n.x[72]; // 2
|
|
DTIME = &t_car_x_n.x[74]; // 1
|
|
TemP = &t_car_x_n.x[75]; // 1
|
|
DTEMP = &t_car_x_n.x[76]; // 1
|
|
COORDS = &t_car_x_n.x[77]; // 3
|
|
DROT = &t_car_x_n.x[80]; // 9
|
|
CELENT = &t_car_x_n.x[89]; // 1
|
|
DFGRD0 = &t_car_x_n.x[90]; // 9
|
|
DFGRD1 = &t_car_x_n.x[99]; // 9
|
|
|
|
NDI = &t_car_x_n.n[216]; // 1
|
|
NSHR = &t_car_x_n.n[217]; // 1
|
|
NTENS = &t_car_x_n.n[218]; // 1
|
|
NSTATV = &t_car_x_n.n[219]; // 1
|
|
NOEL = &t_car_x_n.n[220]; // 1
|
|
NPT = &t_car_x_n.n[221]; // 1
|
|
LAYER = &t_car_x_n.n[222]; // 1
|
|
KSPT = &t_car_x_n.n[223]; // 1
|
|
KSTEP = &t_car_x_n.n[224]; // 1
|
|
KINC = &t_car_x_n.n[225]; // 1
|
|
|
|
CMNAME = &t_car_x_n.tampon[904];
|
|
// le nom
|
|
nom_materiau=CMNAME;
|
|
};
|
|
|
|
// constructeur de copie
|
|
UmatAbaqus::UmatAbaqus(const UmatAbaqus& a) :
|
|
STRESS(NULL),t_sigma(NULL)
|
|
,STATEV(NULL),v_statev(a.v_statev)
|
|
,DDSDDE(NULL),d_sigma_deps(NULL)
|
|
,SSE(NULL),SPD(NULL),SCD(NULL)
|
|
,energie_elastique(a.energie_elastique)
|
|
,dissipation_plastique(a.dissipation_plastique)
|
|
,dissipation_visqueuse(a.dissipation_visqueuse)
|
|
,RPL(NULL),ener_therm_vol_par_utemps(a.ener_therm_vol_par_utemps)
|
|
,DDSDDT(NULL),d_sigma_d_tempera(NULL)
|
|
,DRPLDE(NULL),d_ener_therm_vol_deps(NULL)
|
|
,DRPLDT(NULL),d_ener_therm_dtemper(a.d_ener_therm_dtemper)
|
|
,PNEWDT(NULL),pnewdt(a.pnewdt)
|
|
,STRAN(NULL),eps_meca(NULL)
|
|
,DSTRAN(NULL),delta_eps_meca(NULL)
|
|
,TIME(NULL),temps_t(a.temps_t),temps_tdt(a.temps_tdt)
|
|
,DTIME(NULL),delta_t(a.delta_t)
|
|
,TemP(NULL),temper_t(a.temper_t)
|
|
,DTEMP(NULL),delta_temper(a.delta_temper)
|
|
,PREDEF(NULL),ddlNoeA_ptinteg(a.ddlNoeA_ptinteg)
|
|
,DPRED(NULL),delta_ddlNoeA_ptinteg(a.delta_ddlNoeA_ptinteg)
|
|
,CMNAME(NULL),nom_materiau(a.nom_materiau)
|
|
,NDI(NULL),dim_tens(a.dim_tens)
|
|
,NSHR(NULL),nb_tau_ij(a.nb_tau_ij)
|
|
,NTENS(NULL),nb_ij_tenseur(a.nb_ij_tenseur)
|
|
,NSTATV(NULL),nb_variables_etat(a.nb_variables_etat)
|
|
,PROPS(NULL),proprietes_materiau(a.proprietes_materiau)
|
|
,NPROPS(NULL),nb_proprietes_materiau(a.nb_proprietes_materiau)
|
|
,COORDS(NULL),coor_pt(a.coor_pt)
|
|
,DROT(NULL),mat_corota(a.mat_corota)
|
|
,CELENT(NULL),longueur_characteristique(a.longueur_characteristique)
|
|
,DFGRD0(NULL),giB_t(a.giB_t)
|
|
,DFGRD1(NULL),giB_tdt(a.giB_tdt)
|
|
,NOEL(NULL),nb_elem(a.nb_elem)
|
|
,NPT(NULL),nb_pt_integ(a.nb_pt_integ)
|
|
,LAYER(NULL),nb_du_plis(a.nb_du_plis)
|
|
,KSPT(NULL),nb_pt_dans_le_plis(a.nb_pt_dans_le_plis)
|
|
,KSTEP(NULL),nb_step(a.nb_step)
|
|
,KINC(NULL),nb_increment(a.nb_increment)
|
|
,passage(a.passage),envoi(a.envoi),reception(a.reception)
|
|
,N_t(a.N_t),N_tdt(a.N_tdt)
|
|
{ // on définit les grandeurs pointées au bon endroit dans la chaine de
|
|
// caractères
|
|
// on considère que les int sont codés sur 4 octets, les doubles sur 8
|
|
// On se met dans le cas en 3D (taille maxi) d'où l'ensemble des infos
|
|
// STRESS 6*8=48, STATEV rien on n'en tiend pas compte
|
|
// DDSDDE 36*8= 288, SSE+SPD+SCD 3*8=24
|
|
// RPL 8, DDSDDT 6*8=48, DRPLDE 6*8=48, DRPLDT 8, PNEWDT 8,
|
|
// STRAN 6*8=48, DSTRAN 6*8=48
|
|
// TIME 2*8=16, DTIME 8, TemP 8, DTEMP 8,
|
|
// PREDEF rien on n'en tiens pas compte
|
|
// DPRED rien on n'en tiens pas compte
|
|
// CMNAME 20 (par défaut sur 20 caractères: dans abaqus c'est sur 80)
|
|
// NDI+NSHR+NTENS+NSTATV 4*4=16,
|
|
// PROPS rien on n'en tiens pas compte
|
|
// NPROPS rien on n'en tiens pas compte
|
|
// COORDS 3*8=24, DROT 9*8=72,
|
|
// CELENT 8,
|
|
// DFGRD0 9*8=72, DFGRD1 9*8=72,
|
|
// NOEL+NPT+LAYER+KSPT+KSTEP+KINC 6*4=24
|
|
// total 924 octets
|
|
int* pt1 = &(t_car_x_n.n[0]); const int *pt2= &(a.t_car_x_n.n[0]);
|
|
for (int i=0;i<232;i++,pt1++,pt2++) *pt1=*pt2;
|
|
|
|
// --- en sortie uniquement
|
|
DDSDDT = &t_car_x_n.x[0]; // 6
|
|
DRPLDE = &t_car_x_n.x[6]; // 6
|
|
DDSDDE = &t_car_x_n.x[12]; // 36
|
|
// --- en entrée - sortie
|
|
RPL = &t_car_x_n.x[48]; // 1
|
|
STRESS = &t_car_x_n.x[49]; // 6
|
|
SSE = &t_car_x_n.x[55]; // 1
|
|
SPD = &t_car_x_n.x[56]; // 1
|
|
SCD = &t_car_x_n.x[57]; // 1
|
|
DRPLDT = &t_car_x_n.x[58]; // 1
|
|
PNEWDT = &t_car_x_n.x[59]; // 1
|
|
// --- en entrée seulement
|
|
STRAN = &t_car_x_n.x[60]; // 6
|
|
DSTRAN = &t_car_x_n.x[66]; // 6
|
|
TIME = &t_car_x_n.x[72]; // 2
|
|
DTIME = &t_car_x_n.x[74]; // 1
|
|
TemP = &t_car_x_n.x[75]; // 1
|
|
DTEMP = &t_car_x_n.x[76]; // 1
|
|
COORDS = &t_car_x_n.x[77]; // 3
|
|
DROT = &t_car_x_n.x[80]; // 9
|
|
CELENT = &t_car_x_n.x[89]; // 1
|
|
DFGRD0 = &t_car_x_n.x[90]; // 9
|
|
DFGRD1 = &t_car_x_n.x[99]; // 9
|
|
|
|
NDI = &t_car_x_n.n[216]; // 1
|
|
NSHR = &t_car_x_n.n[217]; // 1
|
|
NTENS = &t_car_x_n.n[218]; // 1
|
|
NSTATV = &t_car_x_n.n[219]; // 1
|
|
NOEL = &t_car_x_n.n[220]; // 1
|
|
NPT = &t_car_x_n.n[221]; // 1
|
|
LAYER = &t_car_x_n.n[222]; // 1
|
|
KSPT = &t_car_x_n.n[223]; // 1
|
|
KSTEP = &t_car_x_n.n[224]; // 1
|
|
KINC = &t_car_x_n.n[225]; // 1
|
|
|
|
CMNAME = &t_car_x_n.tampon[904];
|
|
// le nom
|
|
nom_materiau=CMNAME;
|
|
// cas des grandeurs évoluées
|
|
if (a.t_sigma != NULL)
|
|
t_sigma = NevezTenseurHH(*(a.t_sigma));
|
|
if (a.d_sigma_deps != NULL )
|
|
d_sigma_deps = NevezTenseurHHHH(*(a.d_sigma_deps));
|
|
if (a.d_sigma_d_tempera != NULL)
|
|
d_sigma_d_tempera = NevezTenseurHH(*(a.d_sigma_d_tempera));
|
|
if (a.d_ener_therm_vol_deps != NULL)
|
|
d_ener_therm_vol_deps =NevezTenseurHH(*(a.d_ener_therm_vol_deps));
|
|
if (a.eps_meca != NULL)
|
|
eps_meca = NevezTenseurBB(*(a.eps_meca));
|
|
if (a.delta_eps_meca != NULL)
|
|
delta_eps_meca = NevezTenseurBB(*(a.delta_eps_meca));
|
|
};
|
|
|
|
// DESTRUCTEUR :
|
|
UmatAbaqus::~UmatAbaqus()
|
|
{ // cas des grandeurs évoluées
|
|
if (t_sigma != NULL)
|
|
delete t_sigma;
|
|
if (d_sigma_deps != NULL )
|
|
delete d_sigma_deps;
|
|
if (d_sigma_d_tempera != NULL)
|
|
delete d_sigma_d_tempera;
|
|
if (d_ener_therm_vol_deps != NULL)
|
|
delete d_ener_therm_vol_deps;
|
|
if (eps_meca != NULL)
|
|
delete eps_meca;
|
|
if (delta_eps_meca != NULL)
|
|
delete delta_eps_meca;
|
|
};
|
|
|
|
// Surcharge de l'operateur =
|
|
UmatAbaqus& UmatAbaqus::operator= (UmatAbaqus& a)
|
|
{ t_sigma = a.t_sigma;
|
|
v_statev = a.v_statev;
|
|
d_sigma_deps = a.d_sigma_deps;
|
|
energie_elastique = a.energie_elastique;
|
|
dissipation_plastique = a.dissipation_plastique;
|
|
dissipation_visqueuse = a.dissipation_visqueuse;
|
|
ener_therm_vol_par_utemps = a.ener_therm_vol_par_utemps;
|
|
d_sigma_d_tempera = a.d_sigma_d_tempera;
|
|
d_ener_therm_vol_deps = a.d_ener_therm_vol_deps;
|
|
d_ener_therm_dtemper = a.d_ener_therm_dtemper;
|
|
pnewdt = a.pnewdt;
|
|
eps_meca = a.eps_meca;
|
|
delta_eps_meca = a.delta_eps_meca;
|
|
temps_t = a.temps_t; temps_tdt = a.temps_tdt;
|
|
delta_t = a.delta_t;
|
|
temper_t = a.temper_t;
|
|
delta_temper = a.delta_temper;
|
|
ddlNoeA_ptinteg = a.ddlNoeA_ptinteg;
|
|
delta_ddlNoeA_ptinteg = a.delta_ddlNoeA_ptinteg;
|
|
nom_materiau = a.nom_materiau;
|
|
dim_tens = a.dim_tens;
|
|
nb_tau_ij = a.nb_tau_ij;
|
|
nb_ij_tenseur = a.nb_ij_tenseur;
|
|
nb_variables_etat = a.nb_variables_etat;
|
|
proprietes_materiau = a.proprietes_materiau;
|
|
nb_proprietes_materiau = a.nb_proprietes_materiau;
|
|
coor_pt = a.coor_pt;
|
|
mat_corota = a.mat_corota;
|
|
longueur_characteristique = a.longueur_characteristique;
|
|
giB_t = a.giB_t;
|
|
giB_tdt = a.giB_tdt;
|
|
nb_elem = a.nb_elem;
|
|
nb_pt_integ = a.nb_pt_integ;
|
|
nb_du_plis = a.nb_du_plis;
|
|
nb_pt_dans_le_plis = a.nb_pt_dans_le_plis;
|
|
nb_step = a.nb_step;
|
|
nb_increment = a.nb_increment;
|
|
N_t = a.N_t; N_tdt = a.N_tdt;
|
|
return *this;
|
|
};
|
|
|
|
// lecture des données Umat
|
|
void UmatAbaqus::LectureDonneesUmat(bool utilisation_umat_interne,const int niveau)
|
|
{ // Creation d'un processus de reception des données
|
|
// en fait l'objectif est de réceptionner que les variables d'entrées ou
|
|
// d'entrée sortie
|
|
if (niveau > 5)
|
|
cout << "\n hzpp: ouverture du tube en lecture, lecture sur le tube" << endl;
|
|
if (!utilisation_umat_interne)
|
|
{// dans le cas où l'état actuel de l'incrément est 0,1 ou 2, on initialise le champ de caractères
|
|
if (nb_increment<=2)
|
|
for (int i=0;i<24;i++) CMNAME[i]='\0';
|
|
char* tampon_envoi = &(t_car_x_n.tampon[384]);
|
|
int tub = open(reception.c_str(),O_RDONLY);
|
|
read (tub,tampon_envoi,544);
|
|
close (tub); // fermeture du tampon
|
|
// transformation de l'information
|
|
Copie_base_vers_evolue(niveau);
|
|
if (niveau > 5)
|
|
{ cout << "\n *********** grandeurs lues ************ ";
|
|
cout << "\n sigma_t "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << STRESS[i];
|
|
cout << "\n def "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << STRAN[i];
|
|
cout << "\n deltatdef "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << DSTRAN[i];
|
|
cout << "\n rotation "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DROT[i];
|
|
cout << "\n gradiant_t "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DFGRD0[i];
|
|
cout << "\n gradiant_tdt "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DFGRD1[i];
|
|
cout << "\n temps_t= " << temps_t << " temps_tdt= " << temps_tdt
|
|
<< " delta_t= " << delta_t;
|
|
cout << "\n temper_t= " << temper_t << " delta_temper= " << delta_temper;
|
|
cout << "\n nom_materiau= " << nom_materiau; // nom du matériau
|
|
cout << "\n dim_tens= " << dim_tens << " nb_tau_ij= " << nb_tau_ij
|
|
<< " nb_ij_tenseur= " << nb_ij_tenseur;
|
|
cout << "\n nb_variables_etat= " << nb_variables_etat;
|
|
cout << "\n Coordonnee= " << coor_pt; // coordonnee du point
|
|
cout << "\n mat_corota= " << mat_corota; // matrice de rotation du corotationnelle
|
|
cout << "\n longueur_characteristique= " << longueur_characteristique;
|
|
cout << "\n BaseB giB_t= " << giB_t; // base naturelle à t
|
|
cout << "\n BaseB giB_tdt = " << giB_tdt; // base natuelle à tdt
|
|
if (giB_t.NbVecteur()==2)
|
|
cout <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
cout << "\n nb_elem= " << nb_elem ; // numéro de l'élément
|
|
cout << " nb_pt_integ= " << nb_pt_integ; // numéro du point d'intégration
|
|
cout << " nb_du_plis= " << nb_du_plis; // numéro du plis pour les multicouches
|
|
cout << " nb_pt_dans_le_plis= " << nb_pt_dans_le_plis; // numéro du po cout << "dans le plis
|
|
cout << " nb_step= " << nb_step; // numéro du step
|
|
cout << " nb_increment= " << nb_increment; // numéro de l'incrément
|
|
cout << "\n ******** fin grandeurs lues ************** " << endl;
|
|
};
|
|
|
|
#ifdef SYSTEM_MAC_OS_CARBON
|
|
// def de valeur par défaut pour tester
|
|
STRESS[0]=0.;STRESS[1]=0.;STRESS[2]=0.;STRESS[3]=0.;STRESS[4]=0.;STRESS[5]=0.;
|
|
*SSE = 0.;*SPD = 0.;*SCD = 0.;*RPL = 0.;
|
|
STRAN[0] = 0.01; STRAN[1] = 0.; STRAN[2] = 0.; STRAN[3] = 0.; STRAN[4] = 0.; STRAN[5] = 0.;
|
|
DSTRAN[0] = 0.01; DSTRAN[1] = 0.; DSTRAN[2] = 0.; DSTRAN[3] = 0.; DSTRAN[4] = 0.; DSTRAN[5] = 0.;
|
|
TIME[0] = 0.; TIME[1] = 1.;*DTIME = 1.;
|
|
CMNAME="acier";//CMNAME[5]='\0';
|
|
*NDI=3;*NSHR = 3;*NTENS=6;*NSTATV=0;
|
|
COORDS[0]=1.;COORDS[1]=0.;COORDS[2]=0.;
|
|
DROT[0]=1.;DROT[1]=0.;DROT[2]=0.;DROT[3]=0.;DROT[4]=1.;DROT[5]=0.;DROT[6]=0.;DROT[7]=0.;DROT[8]=1.;
|
|
*CELENT=0.;
|
|
DFGRD0[0]=1.;DFGRD0[1]=0.;DFGRD0[2]=0.;DFGRD0[3]=0.;DFGRD0[4]=1.;
|
|
DFGRD0[5]=0.;DFGRD0[6]=0.;DFGRD0[7]=0.;DFGRD0[8]=1.;
|
|
DFGRD1[0]=1.;DFGRD1[1]=0.;DFGRD1[2]=0.;DFGRD1[3]=0.;DFGRD1[4]=1.;
|
|
DFGRD1[5]=0.;DFGRD1[6]=0.;DFGRD1[7]=0.;DFGRD1[8]=1.;
|
|
*NOEL=1;*NPT=1;*KSTEP=1;*KINC=1;
|
|
#endif
|
|
};
|
|
if (niveau > 5)
|
|
cout << "\n HZpp: fermeture du tube en lecture" << endl;
|
|
// // transformation de l'information
|
|
// Copie_base_vers_evolue();
|
|
// à chaque lecture on incrémente un compteur
|
|
passage++; // pour des comptes éventuelles
|
|
};
|
|
|
|
// écriture des données Umat
|
|
void UmatAbaqus::EcritureDonneesUmat(bool utilisation_umat_interne,const int niveau)
|
|
{ // Creation d'un processus d'ecriture des variables
|
|
// en fait l'objectif est d'ecrire que les variables qui évoluent
|
|
if (niveau > 5)
|
|
cout << "\n hzpp: ouverture du tube en ecriture, ecriture sur le tube " << endl;
|
|
if (!utilisation_umat_interne)
|
|
{ // transformation de l'information
|
|
Copie_evolue_vers_base(niveau);
|
|
// ouverture du tube nomme en ecriture
|
|
int tub = open(envoi.c_str(),O_WRONLY);
|
|
write (tub,t_car_x_n.tampon,480);
|
|
close (tub); // fermeture du tampon
|
|
#ifdef SYSTEM_MAC_OS_CARBON
|
|
if (niveau > 5)
|
|
{// on ecrit les résultats à l'écran
|
|
if ((*NDI == 3) && (*NSHR == 3))
|
|
{ // cas classique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
Tenseur3HHHH& dd_sigma_deps = *((Tenseur3HHHH*) d_sigma_deps);
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
// Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
// Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
}
|
|
else if ((*NDI == 2) && (*NSHR == 1))
|
|
{ // cas contraintes planes
|
|
Tenseur2HH& sigma = *((Tenseur2HH*) t_sigma);
|
|
cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
Tenseur2HHHH& dd_sigma_deps = *((Tenseur2HHHH*) d_sigma_deps);
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
// Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
// Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
cout <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
}
|
|
else
|
|
{ cout << "\n erreur , pour l'instant seule la dimension 3 est en place"
|
|
<< "\n il est vivement conseille de ce plaindre pour remedier a ce probleme "
|
|
<< "\n void UmatAbaqus::EcritureDonneesUmat()" << endl ;
|
|
Sortie(1);
|
|
};
|
|
cout << "\n ************* les energies *********"
|
|
<< "\n energie_elastique: " << energie_elastique
|
|
<< " dissipation_plastique: " << dissipation_plastique
|
|
<< " dissipation_visqueuse: " << dissipation_visqueuse;
|
|
cout << "\n rentrer un caractere pour continuer ? ";
|
|
string toto; toto= lect_chaine();
|
|
// *PNEWDT = pnewdt;
|
|
// *RPL = ener_therm_vol_par_utemps;
|
|
// *DRPLDT = d_ener_therm_dtemper;
|
|
};
|
|
#endif
|
|
};
|
|
if (ParaGlob::NiveauImpression() > 7)
|
|
cout << "\n HZpp: fermeture du tube en ecriture" << endl;
|
|
};
|
|
|
|
// <<<<<< 2) <<<<<< contexte: utilisation par herezh d'une umat extérieure
|
|
// écriture des données pour l'umat
|
|
void UmatAbaqus::EcritureDonneesPourUmat(bool utilisation_umat_interne,const int niveau)
|
|
{ // Creation d'un processus d'ecriture des variables
|
|
// en fait l'objectif est d'ecrire que les variables nécessaires pour le calcul
|
|
if (niveau > 5)
|
|
cout << "\n hzpp-utilisation d'umat: ouverture du tube en ecriture, ecriture sur le tube "
|
|
<< endl;
|
|
if (!utilisation_umat_interne)
|
|
{//transformation de l'information
|
|
Copie_evolue_vers_base_PourUmat(niveau);
|
|
// ouverture du tube nomme en ecriture
|
|
char* tampon_envoi = &(t_car_x_n.tampon[384]);
|
|
int tub = open(reception.c_str(),O_WRONLY);
|
|
if (tub < 0)
|
|
{cout << "\n *** erreur en ouverture du pipe " << reception.c_str()
|
|
<< " peut-etre n'existe t'il pas ? en tout cas il ne veut pas s'ouvrir !! ";
|
|
Sortie(1);
|
|
};
|
|
|
|
write (tub,tampon_envoi,544);
|
|
if (niveau > 5)
|
|
{ cout << "\n *********** donnees envoyees ************ ";
|
|
cout << "\n sigma_t "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << STRESS[i];
|
|
cout << "\n def "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << STRAN[i];
|
|
cout << "\n deltatdef "; for (int i=0;i<6;i++) cout << "("<<i<<")= " << DSTRAN[i];
|
|
cout << "\n rotation "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DROT[i];
|
|
cout << "\n gradiant_t "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DFGRD0[i];
|
|
cout << "\n gradiant_tdt "; for (int i=0;i<9;i++) cout << "("<<i<<")= " << DFGRD1[i];
|
|
cout << "\n temps_t= " << temps_t << " temps_tdt= " << temps_tdt
|
|
<< " delta_t= " << delta_t;
|
|
cout << "\n temper_t= " << temper_t << " delta_temper= " << delta_temper;
|
|
cout << "\n nom_materiau= " << nom_materiau; // nom du matériau
|
|
cout << "\n dim_tens= " << dim_tens << " nb_tau_ij= " << nb_tau_ij
|
|
<< " nb_ij_tenseur= " << nb_ij_tenseur;
|
|
cout << "\n nb_variables_etat= " << nb_variables_etat;
|
|
cout << "\n Coordonnee= " << coor_pt; // coordonnee du point
|
|
cout << "\n mat_corota= " << mat_corota; // matrice de rotation du corotationnelle
|
|
cout << "\n longueur_characteristique= " << longueur_characteristique;
|
|
cout << "\n BaseB giB_t= " << giB_t; // base naturelle à t
|
|
cout << "\n BaseB giB_tdt = " << giB_tdt; // base natuelle à tdt
|
|
if (giB_t.NbVecteur()==2)
|
|
cout <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
cout << "\n nb_elem= " << nb_elem ; // numéro de l'élément
|
|
cout << " nb_pt_integ= " << nb_pt_integ; // numéro du point d'intégration
|
|
cout << " nb_du_plis= " << nb_du_plis; // numéro du plis pour les multicouches
|
|
cout << " nb_pt_dans_le_plis= " << nb_pt_dans_le_plis; // numéro du po cout << "dans le plis
|
|
cout << " nb_step= " << nb_step; // numéro du step
|
|
cout << " nb_increment= " << nb_increment; // numéro de l'incrément
|
|
cout << "\n ******** fin grandeurs envoyees ************** " << endl;
|
|
};
|
|
close (tub); // fermeture du tampon
|
|
};
|
|
if (niveau > 5)
|
|
cout << "\n HZpp-utilisation d'umat: fermeture du tube en ecriture" << endl;
|
|
};
|
|
|
|
// Puis lecture des résultats de l'umat
|
|
void UmatAbaqus::LectureResultatUmat(bool utilisation_umat_interne,const int niveau)
|
|
{ // Creation d'un processus de reception des données
|
|
// en fait l'objectif est de réceptionner que les variables calculées
|
|
// ouverture du tube nomme en lecture
|
|
// lecture dans le t_car_x_n.tampon
|
|
if (niveau > 5)
|
|
cout << "\n hzpp-utilisation d'umat: ouverture du tube en lecture, lecture sur le tube"
|
|
<< endl;
|
|
if (!utilisation_umat_interne)
|
|
{ int tub = open(envoi.c_str(),O_RDONLY);
|
|
read (tub,t_car_x_n.tampon,480);
|
|
close (tub); // fermeture du tampon
|
|
// transformation de l'information
|
|
Copie_base_vers_evolue_PourUmat(niveau);
|
|
};
|
|
if (niveau > 5)
|
|
cout << "\n HZpp-utilisation d'umat: fermeture du tube en lecture" << endl;
|
|
};
|
|
|
|
// initialisation des données d'entrée tous à zéro
|
|
// sauf: nom_materiau: qui reste inchangé
|
|
// giB_t et BaseB: qui sont initialisée à une base absolue identité
|
|
// pnewdt: très grand, matrice de rotation identité
|
|
// sinon on a:
|
|
// *eps_meca, *delta_eps_meca : nulles, temps_t=0, temps_tdt et delta_t=0;
|
|
// temper_t et delta_temper: nulles,
|
|
// pas de variables aux noeuds, pas de proprietes_materiau
|
|
// coordonnées à 0,
|
|
// longueur caractéristique=0,
|
|
// et tous les indices=0:
|
|
// nb_elem nb_pt_integ nb_du_plis nb_pt_dans_le_plis nb_step nb_increment
|
|
void UmatAbaqus::Init_zero()
|
|
{t_sigma->Inita(0.);v_statev.Change_taille(0);
|
|
energie_elastique=0.;dissipation_plastique=0.;dissipation_visqueuse=0.;
|
|
pnewdt = ConstMath::tresgrand;
|
|
eps_meca->Inita(0);delta_eps_meca->Inita(0.);
|
|
temps_t=0.;temps_tdt=0.;delta_t=0.;
|
|
temper_t=0.;delta_temper=0.;
|
|
ddlNoeA_ptinteg.Change_taille(0);
|
|
delta_ddlNoeA_ptinteg.Change_taille(0);
|
|
|
|
//dim_tens=3;nb_tau_ij=3;nb_ij_tenseur=6;
|
|
dim_tens=Abs(eps_meca->Dimension());
|
|
// les valeurs de nb_tau_ij et nb_ij_tenseur
|
|
// dépendent du cas de travail, donc on ne les changes pas ici
|
|
// éventuellement en lecture il seront modifié
|
|
|
|
nb_variables_etat=0.;
|
|
proprietes_materiau.Change_taille(0);nb_proprietes_materiau=0;
|
|
coor_pt.Zero();
|
|
mat_corota.Initialise(0.);mat_corota(1,1)=1.;mat_corota(2,2)=1.;mat_corota(3,3)=1.;
|
|
longueur_characteristique=0.;
|
|
giB_tdt = giB_t=BaseB(giB_t.Dimension(),giB_t.NbVecteur());
|
|
if (giB_t.NbVecteur()==2)
|
|
N_tdt.Zero(); N_t=N_tdt;
|
|
// giB_tdt=BaseB(3);
|
|
nb_elem=1;
|
|
nb_pt_integ=1;
|
|
nb_du_plis=1;
|
|
nb_pt_dans_le_plis=1;
|
|
nb_step=1;
|
|
nb_increment=1;
|
|
};
|
|
|
|
// initialisation des données d'entrée à un démarrage correcte
|
|
// *t_sigma=0, v_statev de taille nulle, les énergies nulles, pnewdt très grand
|
|
// *eps_meca, *delta_eps_meca : nulles, temps_t=0, temps_tdt et delta_t=1;
|
|
// temper_t et delta_temper: nulles,
|
|
// pas de variables aux noeuds, pas de proprietes_materiau
|
|
// coordonnées à 0, matrice de rotation identité
|
|
// longueur caractéristique=1, giB_t et giB_tdt: base identité en absolue
|
|
// et tous les indices=1:
|
|
// nb_elem nb_pt_integ nb_du_plis nb_pt_dans_le_plis nb_step nb_increment
|
|
// par défaut la dimension des tenseurs est 3, mais pour les CP par exemple
|
|
// la dimension réelle utilisée est 2
|
|
// de même pour nb_reel_tau_ij qui indique le nombre de contrainte de cisaillement
|
|
// réellement utilisé: qui en CP = 1
|
|
void UmatAbaqus::Init_un(int dim_reel_tens ,int nb_reel_tau_ij)
|
|
{t_sigma->Inita(0.);v_statev.Change_taille(0);
|
|
energie_elastique=0.;dissipation_plastique=0.;dissipation_visqueuse=0.;
|
|
pnewdt = ConstMath::tresgrand;
|
|
eps_meca->Inita(0);delta_eps_meca->Inita(0.);
|
|
temps_t=0.;temps_tdt=1.;delta_t=1.;
|
|
temper_t=0.;delta_temper=0.;
|
|
ddlNoeA_ptinteg.Change_taille(0);
|
|
delta_ddlNoeA_ptinteg.Change_taille(0);
|
|
dim_tens=dim_reel_tens;
|
|
nb_tau_ij=nb_reel_tau_ij;
|
|
nb_ij_tenseur=dim_tens+nb_tau_ij; // correspond à NTENS,
|
|
// en CP on n'utilise normalement que 4, mais de toute manière
|
|
// on passe systématiquement des tenseurs 3D en paramètre
|
|
nb_variables_etat=0.;
|
|
proprietes_materiau.Change_taille(0);nb_proprietes_materiau=0;
|
|
coor_pt.Zero();
|
|
mat_corota.Initialise(0.);mat_corota(1,1)=1.;mat_corota(2,2)=1.;mat_corota(3,3)=1.;
|
|
longueur_characteristique=1.;
|
|
// giB_t=BaseB(3);giB_tdt=BaseB(3);
|
|
giB_tdt = giB_t=BaseB(giB_t.Dimension(),giB_t.NbVecteur());
|
|
if (giB_t.NbVecteur()==2)
|
|
N_tdt.Zero(); N_t=N_tdt;
|
|
|
|
// nb_elem=1;
|
|
// nb_pt_integ=1;
|
|
nb_du_plis=1;
|
|
nb_pt_dans_le_plis=1;
|
|
// nb_step=1;
|
|
// nb_increment=1;
|
|
};
|
|
|
|
// transfert de l'Umat vers le point d'intégration à t
|
|
void UmatAbaqus::Transfert_Umat_ptInteg_t(PtIntegMecaInterne& ptIntegMeca)
|
|
{ *(ptIntegMeca.EpsBB()) = *eps_meca;
|
|
*(ptIntegMeca.DeltaEpsBB()) = *delta_eps_meca;
|
|
*(ptIntegMeca.SigHH_t()) = *t_sigma;
|
|
};
|
|
// transfert de l'Umat vers le point d'intégration à tdt
|
|
void UmatAbaqus::Transfert_Umat_ptInteg_tdt(PtIntegMecaInterne& ptIntegMeca)
|
|
{ *(ptIntegMeca.SigHH()) = *t_sigma;
|
|
};
|
|
|
|
|
|
// affichage en fonction d'un niveau
|
|
// niveau > 0: données
|
|
void UmatAbaqus::Affiche(ofstream& sort,const int niveau)
|
|
{ sort << "\n *********** info umat ************ ";
|
|
sort << "\n sigma_t "; for (int i=0;i<6;i++) sort << "("<<i<<")= " << STRESS[i];
|
|
sort << "\n def "; for (int i=0;i<6;i++) sort << "("<<i<<")= " << STRAN[i];
|
|
sort << "\n deltatdef "; for (int i=0;i<6;i++) sort << "("<<i<<")= " << DSTRAN[i];
|
|
sort << "\n rotation "; for (int i=0;i<9;i++) sort << "("<<i<<")= " << DROT[i];
|
|
sort << "\n gradiant_t "; for (int i=0;i<9;i++) sort << "("<<i<<")= " << DFGRD0[i];
|
|
sort << "\n gradiant_tdt "; for (int i=0;i<9;i++) sort << "("<<i<<")= " << DFGRD1[i];
|
|
sort << "\n temps_t= " << temps_t << " temps_tdt= " << temps_tdt
|
|
<< " delta_t= " << delta_t;
|
|
sort << "\n temper_t= " << temper_t << " delta_temper= " << delta_temper;
|
|
sort << "\n nom_materiau= " << nom_materiau; // nom du matériau
|
|
sort << "\n dim_tens= " << dim_tens << " nb_tau_ij= " << nb_tau_ij
|
|
<< " nb_ij_tenseur= " << nb_ij_tenseur;
|
|
sort << "\n nb_variables_etat= " << nb_variables_etat;
|
|
sort << "\n Coordonnee= " << coor_pt; // coordonnee du point
|
|
sort << "\n mat_corota= " << mat_corota; // matrice de rotation du corotationnelle
|
|
sort << "\n longueur_characteristique= " << longueur_characteristique;
|
|
sort << "\n BaseB giB_t= " << giB_t; // base naturelle à t
|
|
sort << "\n BaseB giB_tdt = " << giB_tdt; // base natuelle à tdt
|
|
if (giB_t.NbVecteur()==2)
|
|
sort <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
sort << "\n nb_elem= " << nb_elem ; // numéro de l'élément
|
|
sort << " nb_pt_integ= " << nb_pt_integ; // numéro du point d'intégration
|
|
sort << " nb_du_plis= " << nb_du_plis; // numéro du plis pour les multicouches
|
|
sort << " nb_pt_dans_le_plis= " << nb_pt_dans_le_plis; // numéro du po sort << "dans le plis
|
|
sort << " nb_step= " << nb_step; // numéro du step
|
|
sort << " nb_increment= " << nb_increment; // numéro de l'incrément
|
|
sort << "\n ******** fin grandeurs ************** " << endl;
|
|
};
|
|
|
|
//----- lecture écriture de restart -----
|
|
// cas donne le niveau de la récupération
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
void UmatAbaqus::Lecture_base_info(ifstream& ent,const int cas)
|
|
{ string toto,nom;
|
|
if (cas == 1)
|
|
{ ent >> toto;
|
|
if (toto != "StructureUmat_Abaqus")
|
|
{ cout << "\n erreur en lecture des parametres d'une structure Umat abaqus !! "
|
|
<< "\n UmatAbaqus::Lecture_base_info(... ";
|
|
Sortie(1);
|
|
};
|
|
ent >> toto >> envoi >> toto >> reception;
|
|
};
|
|
};
|
|
|
|
// cas donne le niveau de sauvegarde
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void UmatAbaqus::Ecriture_base_info(ofstream& sort,const int cas)
|
|
{ if (cas == 1)
|
|
{ sort << "\n StructureUmat_Abaqus: "
|
|
<< " nom_tube_envoi " << envoi <<" nom_tube_reception= " << reception << " ";
|
|
};
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------
|
|
// méthodes protégées
|
|
// ---------------------------------------------------------------------------------------------
|
|
|
|
// 1)-- utilisation en tant qu'umat
|
|
// copie des grandeurs évoluées dans les grandeurs de base
|
|
// uniquement celles qui varient
|
|
void UmatAbaqus::Copie_evolue_vers_base(const int niveau)
|
|
{ if ((dim_tens == 3) && (nb_tau_ij == 3))
|
|
{ // cas classique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3HHHH& dd_sigma_deps = *((Tenseur3HHHH*) d_sigma_deps);
|
|
Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
for (int ij=1;ij<=6;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
DDSDDT[ij-1] = d_sigma_d_tempe(i,j);
|
|
DRPLDE[ij-1] = d_ener_therm_vol_dep(i,j);
|
|
for (int kl=1;kl<=6;kl++)
|
|
{int k=cdex.idx_i(kl);int l=cdex.idx_j(kl);
|
|
int r=(ij-1)*6+kl-1;
|
|
// DDSDDE[r] = dd_sigma_deps(i,j,k,l);
|
|
// en considérant que la matrice tangente est relative à gamma_ij = eps_ij + eps_ji
|
|
// et non la déformation !!, de plus en considérant que dd_sigma_deps (i,j,k,l)
|
|
// devrait être symétrique par rapport aux deux derniers indices
|
|
// enfin dans l'utilisation on fait directement sig(i,j) = dd(i,j,k,l) * gamma(k,l)
|
|
// et on ne considère pas le cas gamma(l,k), donc il ya seulement 6 gamma
|
|
if (k == l)
|
|
{DDSDDE[r] = dd_sigma_deps(i,j,k,l);}
|
|
else
|
|
// {DDSDDE[r] = 2. * dd_sigma_deps(i,j,k,l);};
|
|
{DDSDDE[r] = 0.5 * (dd_sigma_deps(i,j,k,l)+dd_sigma_deps(i,j,l,k));};
|
|
};
|
|
};
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
};
|
|
}
|
|
else if ((dim_tens == 2) && (nb_tau_ij == 1))
|
|
{ // cas des contraintes planes
|
|
Tenseur2HH& sigma = *((Tenseur2HH*) t_sigma);
|
|
Tenseur2HHHH& dd_sigma_deps = *((Tenseur2HHHH*) d_sigma_deps);
|
|
Tenseur2HH& d_sigma_d_tempe = *((Tenseur2HH*) d_sigma_d_tempera);
|
|
Tenseur2HH& d_ener_therm_vol_dep = *((Tenseur2HH*) d_ener_therm_vol_deps);
|
|
|
|
for (int ij=1;ij<=3;ij++)
|
|
{int i=cdexCP.idx_i(ij);int j=cdexCP.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
DDSDDT[ij-1] = d_sigma_d_tempe(i,j);
|
|
DRPLDE[ij-1] = d_ener_therm_vol_dep(i,j);
|
|
for (int kl=1;kl<=3;kl++)
|
|
{int k=cdexCP.idx_i(kl);int l=cdexCP.idx_j(kl);
|
|
int r=(ij-1)*3+kl-1;
|
|
// DDSDDE[r] = dd_sigma_deps(i,j,k,l);
|
|
// en considérant que la matrice tangente est relative à gamma_ij = eps_ij + eps_ji
|
|
// et non la déformation !!, de plus en considérant que dd_sigma_deps (i,j,k,l)
|
|
// devrait être symétrique par rapport aux deux derniers indices
|
|
// enfin dans l'utilisation on fait directement sig(i,j) = dd(i,j,k,l) * gamma(k,l)
|
|
// et on ne considère pas le cas gamma(l,k), donc il ya seulement 3 gamma
|
|
if (k == l)
|
|
{DDSDDE[r] = dd_sigma_deps(i,j,k,l);}
|
|
else
|
|
{DDSDDE[r] = 0.5 * (dd_sigma_deps(i,j,k,l)+dd_sigma_deps(i,j,l,k));};
|
|
};
|
|
};
|
|
// on s'occupe de mettre à jour la normale
|
|
int i=3;
|
|
for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
DFGRD1[r] = N_tdt(j);
|
|
};
|
|
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
cout <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
};
|
|
}
|
|
else if ((dim_tens == 3) && (nb_tau_ij == 1))
|
|
{ // cas d'éléments axisymétrique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3HHHH& dd_sigma_deps = *((Tenseur3HHHH*) d_sigma_deps);
|
|
Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
for (int ij=1;ij<=4;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
DDSDDT[ij-1] = d_sigma_d_tempe(i,j);
|
|
DRPLDE[ij-1] = d_ener_therm_vol_dep(i,j);
|
|
for (int kl=1;kl<=4;kl++)
|
|
{int k=cdex.idx_i(kl);int l=cdex.idx_j(kl);
|
|
int r=(ij-1)*4+kl-1;
|
|
// DDSDDE[r] = dd_sigma_deps(i,j,k,l);
|
|
// en considérant que la matrice tangente est relative à gamma_ij = eps_ij + eps_ji
|
|
// et non la déformation !!, de plus en considérant que dd_sigma_deps (i,j,k,l)
|
|
// devrait être symétrique par rapport aux deux derniers indices
|
|
// enfin dans l'utilisation on fait directement sig(i,j) = dd(i,j,k,l) * gamma(k,l)
|
|
// et on ne considère pas le cas gamma(l,k), donc il ya seulement 6 gamma
|
|
if (k == l)
|
|
{DDSDDE[r] = dd_sigma_deps(i,j,k,l);}
|
|
else
|
|
// {DDSDDE[r] = 2. * dd_sigma_deps(i,j,k,l);};
|
|
{DDSDDE[r] = 0.5 * (dd_sigma_deps(i,j,k,l)+dd_sigma_deps(i,j,l,k));};
|
|
};
|
|
};
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
};
|
|
}
|
|
else
|
|
{ cout << "\n erreur , pour l'instant seules la dimension 3 et le cas axi sont en place"
|
|
<< "\n il est vivement conseille de ce plaindre pour remedier a ce probleme "
|
|
<< "\n void UmatAbaqus::Copie_evolue_vers_base()" << endl ;
|
|
Sortie(1);
|
|
};
|
|
*SSE = energie_elastique; *SPD = dissipation_plastique; *SCD = dissipation_visqueuse;
|
|
*PNEWDT = pnewdt;
|
|
*RPL = ener_therm_vol_par_utemps;
|
|
*DRPLDT = d_ener_therm_dtemper;
|
|
//cout << "\n sigma_t "; for (int i=0;i<6;i++) cout << " ("<<i<<")=" << STRESS[i];
|
|
//cout << endl;
|
|
};
|
|
|
|
// copie des grandeurs de base vers les grandeurs évoluées
|
|
// uniquement les grandeurs d'entrée (supposées à lire)
|
|
void UmatAbaqus::Copie_base_vers_evolue(const int niveau)
|
|
{ if ((*NDI == 3) && (*NSHR == 3))
|
|
{ // cas classique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3BB& eps_m = *((Tenseur3BB*) eps_meca);
|
|
Tenseur3BB& delta_eps_m = *((Tenseur3BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=6;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
// transformation des gamma en epsilon pour les termes ij, i diff de j
|
|
if (i==j){eps_m.Coor(i,j) = STRAN[ij-1] + DSTRAN[ij-1];
|
|
delta_eps_m.Coor(i,j) = DSTRAN[ij-1];}
|
|
else {eps_m.Coor(i,j) = 0.5 * (STRAN[ij-1] + DSTRAN[ij-1]);
|
|
delta_eps_m.Coor(i,j) = 0.5 * DSTRAN[ij-1];}
|
|
}
|
|
}
|
|
else if ((*NDI == 3) && (*NSHR == 1))
|
|
{ // cas d'éléments axisymétrique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3BB& eps_m = *((Tenseur3BB*) eps_meca);
|
|
Tenseur3BB& delta_eps_m = *((Tenseur3BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=4;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
// transformation des gamma en epsilon pour les termes ij, i diff de j
|
|
if (i==j){eps_m.Coor(i,j) = STRAN[ij-1] + DSTRAN[ij-1];
|
|
delta_eps_m.Coor(i,j) = DSTRAN[ij-1];}
|
|
else {eps_m.Coor(i,j) = 0.5 * (STRAN[ij-1] + DSTRAN[ij-1]);
|
|
delta_eps_m.Coor(i,j) = 0.5 * DSTRAN[ij-1];}
|
|
};
|
|
// maintenant je m'occupe des autres valeurs qui sont nulles
|
|
sigma.Coor(1,3)=sigma.Coor(2,3)=0.;
|
|
eps_m.Coor(1,3)=eps_m.Coor(2,3)=0.;
|
|
delta_eps_m.Coor(1,3)=delta_eps_m.Coor(2,3)=0.;
|
|
}
|
|
else if ((*NDI == 2) && (*NSHR == 1))
|
|
{ // cas d'éléments en contraintes plane
|
|
Tenseur2HH& sigma = *((Tenseur2HH*) t_sigma);
|
|
Tenseur2BB& eps_m = *((Tenseur2BB*) eps_meca);
|
|
Tenseur2BB& delta_eps_m = *((Tenseur2BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=3;ij++)
|
|
{int i=cdexCP.idx_i(ij);int j=cdexCP.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
// transformation des gamma en epsilon pour les termes ij, i diff de j
|
|
if (i==j){eps_m.Coor(i,j) = STRAN[ij-1] + DSTRAN[ij-1];
|
|
delta_eps_m.Coor(i,j) = DSTRAN[ij-1];}
|
|
else {eps_m.Coor(i,j) = 0.5 * (STRAN[ij-1] + DSTRAN[ij-1]);
|
|
delta_eps_m.Coor(i,j) = 0.5 * DSTRAN[ij-1];}
|
|
};
|
|
// maintenant je m'occupe des autres valeurs qui sont nulles
|
|
// sigma(1,3)=sigma(2,3)=sigma(3,3)=0.;
|
|
// eps_m(1,3)=eps_m(2,3)=0.;
|
|
// delta_eps_m(1,3)=delta_eps_m(2,3)=0.;
|
|
}
|
|
else
|
|
{ cout << "\n erreur , pour l'instant seules la dimension 3, le cas contrainte plane et le cas axi sont en place"
|
|
<< "\n il est vivement conseille de ce plaindre pour remedier a ce probleme "
|
|
<< "\n void UmatAbaqus::Copie_base_vers_evolue()" << endl ;
|
|
Sortie(1);
|
|
};
|
|
energie_elastique = dissipation_plastique = dissipation_visqueuse = 0.; // init
|
|
pnewdt= *PNEWDT;
|
|
temps_t= TIME[1]; delta_t = *DTIME; temps_tdt= temps_t+delta_t;
|
|
temper_t = *TemP; delta_temper = *DTEMP;
|
|
dim_tens = *NDI; nb_tau_ij = *NSHR; nb_ij_tenseur = *NTENS; nb_variables_etat = *NSTATV;
|
|
for (int i=1;i<=3;i++)
|
|
{coor_pt(i)= COORDS[i-1];};
|
|
// au niveau des bases il faut intégrer le cas des contraintes planes
|
|
if ((*NDI == 2) && (*NSHR == 1)) // cas contraintes planes
|
|
{for (int i=1;i<=2;i++) // uniquement 2 vecteurs pour les gi
|
|
{for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
mat_corota(i,j)= DROT[r]; giB_t.CoordoB(i)(j)=DFGRD0[r]; giB_tdt.CoordoB(i)(j)=DFGRD1[r];
|
|
};
|
|
};
|
|
// on stocke les normales
|
|
int i=3;
|
|
for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
N_t(j) = DFGRD0[r];
|
|
N_tdt(j) = DFGRD1[r];
|
|
};
|
|
}
|
|
else // autres cas on est en 3D avec 3 vecteurs
|
|
{for (int i=1;i<=3;i++)
|
|
{for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
mat_corota(i,j)= DROT[r]; giB_t.CoordoB(i)(j)=DFGRD0[r]; giB_tdt.CoordoB(i)(j)=DFGRD1[r];
|
|
};
|
|
};
|
|
};
|
|
|
|
longueur_characteristique = *CELENT;
|
|
nb_elem = *NOEL; nb_pt_integ = *NPT; nb_du_plis = *LAYER; nb_pt_dans_le_plis = *KSPT;
|
|
nb_step = *KSTEP; nb_increment = *KINC;
|
|
if (nb_increment <= 1)
|
|
nom_materiau=CMNAME; // le nom du matériau
|
|
};
|
|
|
|
// 2) -- utilisation en tant qu'utilisation d 'une umat extérieure
|
|
// copie des grandeurs de base vers les grandeurs évoluées
|
|
// uniquement celles qui sont des résultats
|
|
void UmatAbaqus::Copie_base_vers_evolue_PourUmat(const int niveau)
|
|
{ if ((*NDI == 3) && (*NSHR == 3))
|
|
{ // cas classique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3HHHH& dd_sigma_deps = *((Tenseur3HHHH*) d_sigma_deps);
|
|
Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
for (int ij=1;ij<=6;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
d_sigma_d_tempe.Coor(i,j) = DDSDDT[ij-1];
|
|
d_ener_therm_vol_dep.Coor(i,j) = DRPLDE[ij-1];
|
|
for (int kl=1;kl<=6;kl++)
|
|
{int k=cdex.idx_i(kl);int l=cdex.idx_j(kl);
|
|
int r=(ij-1)*6+kl-1;
|
|
// en considérant que la matrice tangente est relative à gamma_ij = eps_ij + eps_ji
|
|
// et non la déformation !!, de plus en considérant que dd_sigma_deps (i,j,k,l)
|
|
// devrait être symétrique par rapport aux deux derniers indices
|
|
// enfin dans l'utilisation on fait directement sig(i,j) = dd(i,j,k,l) * gamma(k,l)
|
|
// et on ne considère pas le cas gamma(l,k), donc il ya seulement 6 gamma
|
|
dd_sigma_deps.Change(i,j,k,l,DDSDDE[r]);
|
|
// if (k == l)
|
|
// {dd_sigma_deps.Change(i,j,k,l,DDSDDE[r]);}
|
|
// else
|
|
// {dd_sigma_deps.Change(i,j,k,l,0.5*DDSDDE[r]);};
|
|
};
|
|
};
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
};
|
|
}
|
|
else if ((*NDI == 2) && (*NSHR == 1))
|
|
{ // cas des contraintes planes
|
|
Tenseur2HH& sigma = *((Tenseur2HH*) t_sigma);
|
|
Tenseur2HHHH& dd_sigma_deps = *((Tenseur2HHHH*) d_sigma_deps);
|
|
Tenseur2HH& d_sigma_d_tempe = *((Tenseur2HH*) d_sigma_d_tempera);
|
|
Tenseur2HH& d_ener_therm_vol_dep = *((Tenseur2HH*) d_ener_therm_vol_deps);
|
|
for (int ij=1;ij<=3;ij++)
|
|
{int i=cdexCP.idx_i(ij);int j=cdexCP.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
d_sigma_d_tempe.Coor(i,j) = DDSDDT[ij-1];
|
|
d_ener_therm_vol_dep.Coor(i,j) = DRPLDE[ij-1];
|
|
for (int kl=1;kl<=3;kl++)
|
|
{int k=cdexCP.idx_i(kl);int l=cdexCP.idx_j(kl);
|
|
int r=(ij-1)*3+kl-1;
|
|
dd_sigma_deps.Change(i,j,k,l,DDSDDE[r]);
|
|
};
|
|
};
|
|
// on met également à jour la normale finale
|
|
// ce qui permet de récupérer ensuite la déformation d'épaisseur
|
|
int i=3;
|
|
for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
N_tdt(j) = DFGRD1[r];
|
|
};
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
cout <<"\n N_t= "<<N_t <<", N_tdt= "<<N_tdt;
|
|
};
|
|
}
|
|
else if ((*NDI == 3) && (*NSHR == 1))
|
|
{ // cas d'éléments axisymétrique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3HHHH& dd_sigma_deps = *((Tenseur3HHHH*) d_sigma_deps);
|
|
Tenseur3HH& d_sigma_d_tempe = *((Tenseur3HH*) d_sigma_d_tempera);
|
|
Tenseur3HH& d_ener_therm_vol_dep = *((Tenseur3HH*) d_ener_therm_vol_deps);
|
|
for (int ij=1;ij<=4;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
sigma.Coor(i,j) = STRESS[ij-1];
|
|
d_sigma_d_tempe.Coor(i,j) = DDSDDT[ij-1];
|
|
d_ener_therm_vol_dep.Coor(i,j) = DRPLDE[ij-1];
|
|
for (int kl=1;kl<=4;kl++)
|
|
{int k=cdex.idx_i(kl);int l=cdex.idx_j(kl);
|
|
int r=(ij-1)*4+kl-1;
|
|
dd_sigma_deps.Change(i,j,k,l,DDSDDE[r]);
|
|
};
|
|
};
|
|
// maintenant je m'occupe des autres valeurs qui sont nulles
|
|
sigma.Coor(1,3)=sigma.Coor(2,3)=0.;
|
|
d_sigma_d_tempe.Coor(1,3)=d_sigma_d_tempe.Coor(2,3)=0.;
|
|
d_ener_therm_vol_dep.Coor(1,3)=d_ener_therm_vol_dep.Coor(2,3)=0.;
|
|
if (niveau > 5)
|
|
{ cout << "\n ************* contraintes calculees: *********\n" << sigma;
|
|
cout << "\n ************* matrice tangente ***************\n" << dd_sigma_deps;
|
|
};
|
|
}
|
|
else
|
|
{ cout << "\n erreur , pour l'instant seules la dimension 3 et le cas axi sont en place"
|
|
<< "\n il est vivement conseille de ce plaindre pour remedier a ce probleme "
|
|
<< "\n void UmatAbaqus::Copie_evolue_vers_base()" << endl ;
|
|
Sortie(1);
|
|
};
|
|
energie_elastique = *SSE; dissipation_plastique = *SPD; dissipation_visqueuse = *SCD;
|
|
pnewdt = *PNEWDT ;
|
|
ener_therm_vol_par_utemps = *RPL ;
|
|
d_ener_therm_dtemper = *DRPLDT;
|
|
if (niveau > 5)
|
|
{ cout << "\n sigma_t ";
|
|
for (int i=0;i<(*NDI+*NSHR);i++) cout << " ("<<i<<")=" << STRESS[i];
|
|
cout << endl;
|
|
};
|
|
};
|
|
|
|
// copie des grandeurs évoluées dans les grandeurs de base
|
|
// uniquement celles qui sont des données
|
|
void UmatAbaqus::Copie_evolue_vers_base_PourUmat(const int niveau)
|
|
{ if ((dim_tens == 3) && (nb_tau_ij == 3))
|
|
{ // cas classique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3BB& eps_m = *((Tenseur3BB*) eps_meca);
|
|
Tenseur3BB& delta_eps_m = *((Tenseur3BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=6;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
// passage des déformations en gamma pour les termes ij, i diff de j
|
|
if (i == j)
|
|
{STRAN[ij-1] = eps_m(i,j) - delta_eps_m(i,j);
|
|
DSTRAN[ij-1] = delta_eps_m(i,j);
|
|
}
|
|
else
|
|
{STRAN[ij-1] = 2. * (eps_m(i,j) - delta_eps_m(i,j));
|
|
DSTRAN[ij-1] = 2. * delta_eps_m(i,j);
|
|
};
|
|
};
|
|
}
|
|
else if ((dim_tens == 2) && (nb_tau_ij == 1))
|
|
{ // cas des contraintes planes
|
|
Tenseur2HH& sigma = *((Tenseur2HH*) t_sigma);
|
|
Tenseur2BB& eps_m = *((Tenseur2BB*) eps_meca);
|
|
Tenseur2BB& delta_eps_m = *((Tenseur2BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=3;ij++)
|
|
{int i=cdexCP.idx_i(ij);int j=cdexCP.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
// passage des déformations en gamma pour les termes ij, i diff de j
|
|
if (i == j)
|
|
{STRAN[ij-1] = eps_m(i,j) - delta_eps_m(i,j);
|
|
DSTRAN[ij-1] = delta_eps_m(i,j);
|
|
}
|
|
else
|
|
{STRAN[ij-1] = 2. * (eps_m(i,j) - delta_eps_m(i,j));
|
|
DSTRAN[ij-1] = 2. * delta_eps_m(i,j);
|
|
};
|
|
};
|
|
}
|
|
else if ((dim_tens == 3) && (nb_tau_ij == 1))
|
|
{ // cas d'éléments axisymétrique 3D
|
|
Tenseur3HH& sigma = *((Tenseur3HH*) t_sigma);
|
|
Tenseur3BB& eps_m = *((Tenseur3BB*) eps_meca);
|
|
Tenseur3BB& delta_eps_m = *((Tenseur3BB*) delta_eps_meca);
|
|
for (int ij=1;ij<=4;ij++)
|
|
{int i=cdex.idx_i(ij);int j=cdex.idx_j(ij);
|
|
STRESS[ij-1] = sigma(i,j);
|
|
// passage des déformations en gamma pour les termes ij, i diff de j
|
|
if (i == j)
|
|
{STRAN[ij-1] = eps_m(i,j) - delta_eps_m(i,j);
|
|
DSTRAN[ij-1] = delta_eps_m(i,j);
|
|
}
|
|
else
|
|
{STRAN[ij-1] = 2. * (eps_m(i,j) - delta_eps_m(i,j));
|
|
DSTRAN[ij-1] = 2. * delta_eps_m(i,j);
|
|
};
|
|
};
|
|
}
|
|
else
|
|
{ cout << "\n erreur , pour l'instant seules la dimension 3 et le cas axi sont en place"
|
|
<< "\n il est vivement conseille de ce plaindre pour remedier a ce probleme "
|
|
<< "\n void UmatAbaqus::Copie_base_vers_evolue()" << endl ;
|
|
Sortie(1);
|
|
};
|
|
*PNEWDT = pnewdt;
|
|
TIME[0] = temps_t; // par défaut on met un step = la durée totale
|
|
TIME[1] = temps_t; *DTIME = delta_t;
|
|
*TemP = temper_t ; *DTEMP = delta_temper ;
|
|
*NDI = dim_tens ; *NSHR = nb_tau_ij ; *NTENS = nb_ij_tenseur ; *NSTATV = nb_variables_etat;
|
|
for (int i=1;i<=3;i++)
|
|
{COORDS[i-1] = coor_pt(i);};
|
|
// au niveau des bases il faut intégrer le cas des contraintes planes
|
|
if ((*NDI == 2) && (*NSHR == 1)) // cas contraintes planes
|
|
{ for (int i=1;i<=2;i++) // uniquement 2 vecteurs pour les gi
|
|
{for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
DROT[r] = mat_corota(i,j); DFGRD0[r] = giB_t (i)(j); DFGRD1[r] =giB_tdt(i)(j);
|
|
};
|
|
};
|
|
// pour la troisième direction, mat_corota normalement est bien initialisé
|
|
// et on init les autres à un vecteur unitaire normale
|
|
int i=3; // le cas de la troisième direction
|
|
{for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
DROT[r] = mat_corota(i,j);
|
|
DFGRD0[r] = N_t(j);
|
|
DFGRD1[r] = N_tdt(j);
|
|
};
|
|
};
|
|
}
|
|
else // autres cas on est en 3D avec 3 vecteurs
|
|
{for (int i=1;i<=3;i++)
|
|
{COORDS[i-1] = coor_pt(i);
|
|
for (int j=1;j<=3;j++)
|
|
{int r=(i-1)*3+j-1;
|
|
DROT[r] = mat_corota(i,j); DFGRD0[r] = giB_t (i)(j); DFGRD1[r] =giB_tdt(i)(j);
|
|
};
|
|
};
|
|
};
|
|
|
|
*CELENT = longueur_characteristique ;
|
|
*NOEL = nb_elem ; *NPT = nb_pt_integ ; *LAYER = nb_du_plis ; *KSPT = nb_pt_dans_le_plis ;
|
|
*KSTEP = nb_step; *KINC = nb_increment;
|
|
if (nb_increment <= 1)
|
|
{ int longueur = nom_materiau.length();
|
|
// longueur = 5;
|
|
if (longueur > 24)
|
|
{cout << "\n erreur: le nom du materiau a une longueur superieur a 24, pas possible actuellement"
|
|
<< "\n UmatAbaqus::Copie_evolue_vers_base_PourUmat()";
|
|
Sortie(1);
|
|
};
|
|
for (int i=0;i<longueur;i++)
|
|
CMNAME[i]=(nom_materiau.c_str())[i];
|
|
CMNAME[longueur]='\0';
|
|
};
|
|
};
|
|
|
|
|
|
|