modifications d'édition, tabulation, orthographe ...

This commit is contained in:
Gérard Rio 2023-06-12 17:30:26 +02:00
parent a60ae7db18
commit a94858e424
34 changed files with 875 additions and 1242 deletions

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View file

@ -113,12 +113,12 @@ bool GeomPentaCom::Interieur(const Coordonnee& M)
// dont les coordonnées sont sur la droite GM: c-a-d GP = alpha GM, avec apha maxi et P appartenant à la frontière
// de l'élément, G étant le centre de gravité, sauf si GM est nul, dans ce cas retour de M
Coordonnee GeomPentaCom::Maxi_Coor_dans_directionGM(const Coordonnee& M)
{ // on décompose la recherche en segment et facette
double x=M(1); double y=M(2); double z=M(3);
// tout d'abord on calcul le point maxi dans le plan 1 2 et dans z indépendemment
Coordonnee XY(x,y); Coordonnee Z(z);
Coordonnee Pxy= face(1)->Maxi_Coor_dans_directionGM(XY);
Coordonnee Pz = seg(1)->Maxi_Coor_dans_directionGM(Z);
{ // on décompose la recherche en segment et facette
double x=M(1); double y=M(2); double z=M(3);
// tout d'abord on calcul le point maxi dans le plan 1 2 et dans z indépendemment
Coordonnee XY(x,y); Coordonnee Z(z);
Coordonnee Pxy= face(1)->Maxi_Coor_dans_directionGM(XY);
Coordonnee Pz = seg(1)->Maxi_Coor_dans_directionGM(Z);
Coordonnee P(0.,0.,0.); // le retour
// G le centre de gravité: il a la cote nulle et il est centre de gravité du triangle médian
@ -143,10 +143,10 @@ Coordonnee GeomPentaCom::Maxi_Coor_dans_directionGM(const Coordonnee& M)
if (gmxy > ConstMath::trespetit)
{ double z_P = z * ( (Pxy-Gxy).Norme()) / gmxy;
if (Abs(z_P) <= 1.) // là c'est ok on sort par un rectangle
{P(1)=Pxy(1); P(2)=Pxy(2); P(3)=z_P;
fin_traitement = true;// pour indiquer que c'est ok
};
};
{P(1)=Pxy(1); P(2)=Pxy(2); P(3)=z_P;
fin_traitement = true;// pour indiquer que c'est ok
};
};
// 2)----
// dans le cas où fin_traitement est toujours faux, cela signifie que le cas sortie par un quadrangle n'a pas marché
// donc cela signifie que le point P est sur la face sup ou inf. En fait cela dépend de z_M si c'est positif alors
@ -155,31 +155,31 @@ Coordonnee GeomPentaCom::Maxi_Coor_dans_directionGM(const Coordonnee& M)
// d'où GPxy = z_P * GMxy/z_M = e (en module) d'où \vec{GPxy} = e * \vec{GMxy)/||GMxy|| = z_P / z_M * \vec{GMxy) d'où P
if (! fin_traitement)
{ if (z > ConstMath::trespetit)
{ // cas d'une sortie par la facette supérieure, z_P = 1.
Coordonnee GPxy = GMxy / z;
P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = 1.;
fin_traitement = true;// pour indiquer que c'est ok
}
else if (z < -ConstMath::trespetit)
{ // cas d'une sortie par la facette inférieure, z_P = -1.
Coordonnee GPxy = (-1./z) * GMxy ;
P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = -1.;
fin_traitement = true;// pour indiquer que c'est ok
}
else
// arrivée ici, cela veut dire que z est quasiment nulle, et pourtant due au 1)---
// - soit Abs(z_P) est > 1 , ce qui n'est pas possible car on vient de trouver z quasiment nulle
// - soit gmxy est également quasiment nulle : dans ce cas on choisit arbitrairement P(0,0,0)
{ P.Zero();};
};
{ // cas d'une sortie par la facette supérieure, z_P = 1.
Coordonnee GPxy = GMxy / z;
P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = 1.;
fin_traitement = true;// pour indiquer que c'est ok
}
else if (z < -ConstMath::trespetit)
{ // cas d'une sortie par la facette inférieure, z_P = -1.
Coordonnee GPxy = (-1./z) * GMxy ;
P(1) = untiers + GPxy(1); P(2) = untiers + GPxy(2); P(3) = -1.;
fin_traitement = true;// pour indiquer que c'est ok
}
else
// arrivée ici, cela veut dire que z est quasiment nulle, et pourtant due au 1)---
// - soit Abs(z_P) est > 1 , ce qui n'est pas possible car on vient de trouver z quasiment nulle
// - soit gmxy est également quasiment nulle : dans ce cas on choisit arbitrairement P(0,0,0)
{ P.Zero();};
};
#ifdef MISE_AU_POINT
if ((P(1) + P(2)) > (1. + ConstMath::petit))
{ cout << "\n petit soucis, le point maxi calcule n'est pas correcte ";
P.Affiche(cout);
cout << "\n GeomPentaCom::Maxi_Coor_dans_directionGM(.." << endl;
};
#endif
#ifdef MISE_AU_POINT
if ((P(1) + P(2)) > (1. + ConstMath::petit))
{ cout << "\n petit soucis, le point maxi calcule n'est pas correcte ";
P.Affiche(cout);
cout << "\n GeomPentaCom::Maxi_Coor_dans_directionGM(.." << endl;
};
#endif
/*
// en fait il y a un pb, car la suite à l'air correcte si on cherche l'intersection de OM avec la frontière

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View file

@ -69,10 +69,10 @@ class Met_Pout2D : public Met_PiPoCo
// Constructeur par defaut
Met_Pout2D ();
// constructeur permettant de dimensionner unique ment certaine variables
// dim = dimension de l'espace, tab = liste
// des variables a initialiser
Met_Pout2D (int dim_base,int nbvec,const DdlElement& tabddl,
// constructeur permettant de dimensionner uniquement certaine variables
// dim = dimension de l'espace, tab = liste
// des variables a initialiser
Met_Pout2D (int dim_base,int nbvec,const DdlElement& tabddl,
const Tableau<Enum_variable_metrique>& tabb,int nomb_noeud);
// constructeur de copie
Met_Pout2D (const Met_Pout2D&);
@ -80,24 +80,24 @@ class Met_Pout2D : public Met_PiPoCo
~Met_Pout2D ();
// METHODES PUBLIQUES :
// Surcharge de l'operateur = : realise l'affectation
// dérivant de virtuel, a ne pas employer -> message d'erreur
Met_abstraite& operator= (const Met_abstraite& met);
Met_PiPoCo& operator= (const Met_PiPoCo& met);
// normale
virtual Met_Pout2D& operator= (const Met_Pout2D& met);
// passage de la dérivée seconde
void DeriveeSeconde(Vecteur const & tabD2phi);
// Surcharge de l'operateur = : realise l'affectation
// dérivant de virtuel, a ne pas employer -> message d'erreur
Met_abstraite& operator= (const Met_abstraite& met);
Met_PiPoCo& operator= (const Met_PiPoCo& met);
// normale
virtual Met_Pout2D& operator= (const Met_Pout2D& met);
// passage de la dérivée seconde
void DeriveeSeconde(Vecteur const & tabD2phi);
// ============================ protege ===========================
protected :
// calcul des normales a la poutre
void Calcul_N_0 ();
void Calcul_N_t ();
void Calcul_N_tdt ();
// calcul des normales a la poutre
void Calcul_N_0 ();
void Calcul_N_t ();
void Calcul_N_tdt ();
//== les fonctions de calcul de base donc redefini
// calcul de la base naturel a t0
// pendant le traitement il y a calcul de la base aiB et aiH de l'axe médian

View file

@ -72,13 +72,13 @@ PoutSimple1::DonnCommunPS1::DonnCommunPS1(DonnCommunPS1& a) :
,matrice_masse(a.matrice_masse)
{};
PoutSimple1::DonnCommunPS1::DonnCommunPS1::~DonnCommunPS1()
{ int nbddl = tab_ddl.NbDdl();
{ int nbddl = tab_ddl.NbDdl();
int nbi=d2_epsBB.Taille();
for (int ni=1;ni<=nbi;ni++)
for (int i1=1; i1<= nbddl; i1++)
for (int i2=1; i2<= nbddl; i2++)
delete d2_epsBB(ni)(i1,i2);
};
for (int i1=1; i1<= nbddl; i1++)
for (int i2=1; i2<= nbddl; i2++)
delete d2_epsBB(ni)(i1,i2);
};
// ---------- fin definition de la classe conteneur de donnees communes ------------
@ -106,27 +106,25 @@ PoutSimple1::ConstrucElementPoutSimple1 PoutSimple1::construcElementPoutSimple1;
// fonction privee
// dans cette fonction il ne doit y avoir que les données communes !!
void PoutSimple1::Def_DonnCommunPS1()
{ GeomSeg segmentL(nbintL,nbNoeud) ; // element geometrique correspondant de l'axe
GeomSeg segmentH(nbintH) ; // element geometrique correspondant à l'épaisseur
// par défaut le nombre de noeuds est 2
// degre de liberte
int dim = ParaGlob::Dimension();
DdlElement tab_ddl(nbNoeud,dim);
int posi = Id_nom_ddl("X1") -1;
for (int i =1; i<= ParaGlob::Dimension(); i++)
for (int j =1; j<= nbNoeud; j++)
// tab_ddl (j,i) = Enum_ddl(i+posi);
tab_ddl.Change_Enum(j,i,Enum_ddl(i+posi));
{ GeomSeg segmentL(nbintL,nbNoeud) ; // element geometrique correspondant de l'axe
GeomSeg segmentH(nbintH) ; // element geometrique correspondant à l'épaisseur
// par défaut le nombre de noeuds est 2
// degre de liberte
int dim = ParaGlob::Dimension();
DdlElement tab_ddl(nbNoeud,dim);
int posi = Id_nom_ddl("X1") -1;
for (int i =1; i<= ParaGlob::Dimension(); i++)
for (int j =1; j<= nbNoeud; j++)
tab_ddl.Change_Enum(j,i,Enum_ddl(i+posi));
// cas des ddl éléments secondaires pour le calcul d'erreur
// les tenseurs de contrainte sont de dimension 1 a priori
// donc 1 ddl sig11
DdlElement tab_ddlErr(nbNoeud,1);
posi = Id_nom_ddl("SIG11") -1;
for (int j=1; j<= nbNoeud; j++)
// tab_ddlErr (j,1) = Enum_ddl(1+posi);
tab_ddlErr.Change_Enum(j,1,Enum_ddl(1+posi));
// def metrique
// on definit les variables a priori toujours utiles
tab_ddlErr.Change_Enum(j,1,Enum_ddl(1+posi));
// def metrique
// on definit les variables a priori toujours utiles
Tableau<Enum_variable_metrique> tab(24);
tab(1) = iM0; tab(2) = iMt; tab(3) = iMtdt ;
tab(4) = igiB_0; tab(5) = igiB_t; tab(6) = igiB_tdt;
@ -136,10 +134,10 @@ void PoutSimple1::Def_DonnCommunPS1()
tab(16)= id_gijBB_tdt; tab(17)= id_giH_tdt; tab(18)= id_gijHH_tdt;
tab(19)= idMtdt ; tab(20)= id_jacobien_tdt;tab(21)= id2_gijBB_tdt;
tab(22)= igradVBB_tdt; tab(23) = iVtdt; tab(24)= idVtdt;
// dim du pb , nb de vecteur de la base = 1 ici,
// , tableau de ddl et la def de variables
Met_Pout2D metri(ParaGlob::Dimension(),1,tab_ddl,tab,nbNoeud) ;
// ---- cas du calcul d'erreur sur sigma ou epsilon
// dim du pb , nb de vecteur de la base = 1 ici,
// , tableau de ddl et la def de variables
Met_Pout2D metri(ParaGlob::Dimension(),1,tab_ddl,tab,nbNoeud) ;
// ---- cas du calcul d'erreur sur sigma ou epsilon
Tableau <Vecteur *> resEr(nbNoeud);
for (int i=1; i<= nbNoeud; i++)
resEr(i)=new Vecteur (1); // tenseur à une dimension
@ -150,13 +148,13 @@ void PoutSimple1::Def_DonnCommunPS1()
// definition de la classe static contenant toute les variables communes aux PoutSimple1s
doCoPS1 = new DonnCommunPS1(segmentL,segmentH,tab_ddl,metri,resEr,raidEr,matmasse,nbintL*nbintH);
//dimensionnement des variations des deformations
int nbddl = tab_ddl.NbDdl();
int nbddl = tab_ddl.NbDdl();
d_epsBB.Change_taille(nbddl);
d_sigHH.Change_taille(nbddl);
for (int i=1; i<= nbddl; i++)
{ d_epsBB(i) = NevezTenseurBB (1);
d_sigHH(i) = NevezTenseurHH (1);
}
}
};
PoutSimple1::PoutSimple1 () :
// Constructeur par defaut
@ -172,7 +170,7 @@ PiPoCo(),lesPtMecaInt(),donnee_specif()
return;
}
id_interpol=CUBIQUE; // donnees de la classe mere
id_geom=PS1; //
id_geom=PS1; //
// stockage des donnees particulieres de la loi de comportement mécanique au point d'integ
tabSaveDon.Change_taille(nbintL*nbintH);
// stockage des donnees particulieres de la loi de comportement thermo mécanique au point d'integ
@ -181,31 +179,31 @@ PiPoCo(),lesPtMecaInt(),donnee_specif()
tabSaveDefDon.Change_taille(nbintL*nbintH);
tab_energ.Change_taille(nbintL*nbintH);
tab_energ_t.Change_taille(nbintL*nbintH);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout); // met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
// idem pour la masse ici par simplicité
defMas = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout); // met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
// idem pour la masse ici par simplicité
defMas = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
//dimensionnement des deformations et contraintes etc..
int dimtens = 1;
@ -241,26 +239,26 @@ PiPoCo(num_mail,num_id,CUBIQUE,PS1),lesPtMecaInt()
tabSaveDefDon.Change_taille(nbintL*nbintH);
tab_energ.Change_taille(nbintL*nbintH);
tab_energ_t.Change_taille(nbintL*nbintH);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
//dimensionnement des deformations et contraintes etc..
int dimtens = 1;
@ -294,26 +292,26 @@ PoutSimple1::PoutSimple1 (int num_mail,int num_id) :
tabSaveDefDon.Change_taille(nbintL*nbintH);
tab_energ.Change_taille(nbintL*nbintH);
tab_energ_t.Change_taille(nbintL*nbintH);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
tab_noeud.Change_taille(nbNoeud);
// le fait de mettre les pointeurs a null permet
// de savoir que l'element n'est pas complet
for (int i=1; i<= nbNoeud; i++)
tab_noeud(i) = NULL;
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
//dimensionnement des deformations et contraintes etc..
int dimtens = 1;
@ -349,25 +347,25 @@ PiPoCo(num_mail,num_id,tab,CUBIQUE,PS1),lesPtMecaInt()
tabSaveDefDon.Change_taille(nbintL*nbintH);
tab_energ.Change_taille(nbintL*nbintH);
tab_energ_t.Change_taille(nbintL*nbintH);
if (tab_noeud.Taille() != nbNoeud)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " PoutSimple1::PoutSimple1 (double sect,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
if (tab_noeud.Taille() != nbNoeud)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " PoutSimple1::PoutSimple1 (double sect,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// definition des donnees communes aux PoutSimple1s
// a la premiere definition d'une PoutSimple1
if (doCoPS1 == NULL) Def_DonnCommunPS1();
met = &(doCoPS1->met_pout);// met est defini dans elemeca
// --- cas de la dynamique -----
mat_masse = &(doCoPS1->matrice_masse);
// pour les dérivées secondes, transformation de tableau en vecteur
tabD2phi.Change_taille((doCoPS1->segmentL).taD2phi().Taille());
for (int i=1;i<= (doCoPS1->segmentL).taD2phi().Taille(); i++)
tabD2phi(i) = ((doCoPS1->segmentL).taD2phi())(i).Ligne(1);
// def pointe sur la deformation specifique a l'element
def = new DeformationP2D(*met,tab_noeud
,(doCoPS1->segmentH).TaDphi(),(doCoPS1->segmentH).TaPhi()
,(doCoPS1->segmentL).TaDphi(),(doCoPS1->segmentL).TaPhi()
,tabD2phi);
//dimensionnement des deformations et contraintes etc..
int dimtens = 1;
@ -388,12 +386,10 @@ PoutSimple1::PoutSimple1 (const PoutSimple1& pout) :
// Constructeur de copie
{ lesPtIntegMecaInterne = &lesPtMecaInt; // association avec le pointeur d'ElemMeca
// stockage des donnees particulieres de la loi de comportement au point d'integ
// tabSaveDon.Change_taille(1);
*(residu) = *(pout.residu);
*(raideur) = *(pout.raideur);
// met = (pout.met); // la métrique est commune
// *def = *(pout.def);
};
// tabSaveDon.Change_taille(1);
*(residu) = *(pout.residu);
*(raideur) = *(pout.raideur);
};
PoutSimple1::~PoutSimple1 ()
// Destructeur
@ -401,7 +397,7 @@ PoutSimple1::~PoutSimple1 ()
// donc pas de delete
if (ParaGlob::Dimension() != 2) return;
// cas normal
LibereTenseur();
LibereTenseur();
};
// Lecture des donnees de la classe sur fichier
@ -429,21 +425,12 @@ PoutSimple1::LectureDonneesParticulieres
tab_noeud(i) = (*tabMaillageNoeud)(nb); // lecture normale
}
#else
/* #ifdef SYSTEM_MAC_OS_X_unix
else if ((entreePrinc->entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(entreePrinc->entree) >> nb;
tab_noeud(i) = (*tabMaillageNoeud)(nb); // lecture normale
}
#else*/
else if ((entreePrinc->entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ tab_noeud(i) = (*tabMaillageNoeud)(nb); // lecture
// si ce n'est pas la fin de la lecture on appelle un nouvel enregistrement
if (i != nbNoeud) entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
}
// #endif
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
@ -872,118 +859,7 @@ int PoutSimple1::TestComplet()
Tableau <ElFrontiere*> const & PoutSimple1::Frontiere(bool force)
{ int cas = 6; // on veut des lignes et des points
return Frontiere_elemeca(cas,force);
// { // le calcul et la création ne sont effectués qu'au premier appel
// // ou lorsque l'on veut forcer une recréation
// if (((ind_front_lin == 0) && (ind_front_surf == 0) && (ind_front_point == 0))
// || force )
//// if ((ind_front_point == 0) || force || (ind_front_point == 2))
// { // dimensionnement des tableaux intermediaires
// Tableau <Noeud *> tab(1); // les noeuds des points frontieres
// DdlElement ddelem(1); // les ddlelements des points frontieres
// int tail;
// if ((ParaGlob::Dimension() == 1) && (ind_front_lin > 0))
// tail = 3; // deux points et une ligne
// else if (ParaGlob::Dimension() == 1) // cas sans ligne
// tail = 2; // 2 points
// else // cas d'une dimension 2 et 3
// { tail = 3; // deux points et une ligne
// ind_front_lin = 1;
// }
// tabb.Change_taille(tail); // le tableau total de frontières
//
// // premier point
// tab(1) = tab_noeud(1);
// ddelem.Change_un_ddlNoeudElement(1,doCoPS1->tab_ddl(1));
// // ddelem(1) = doCoPS1->tab_ddl(1);
// if (tabb(1+posi_tab_front_point) == NULL)
// tabb(1+posi_tab_front_point) = new FrontPointF (tab,ddelem);
// // second point
// tab(1) = tab_noeud(2);
// ddelem.Change_un_ddlNoeudElement(1,doCoPS1->tab_ddl(2));
// // ddelem(1) = doCoPS1->tab_ddl(2);
// if (tabb(2+posi_tab_front_point) == NULL)
// tabb(2+posi_tab_front_point) = new FrontPointF (tab,ddelem);
// // 3 ieme cote eventuelle
// if (ind_front_lin > 0)
// // cas où il y a une ligne, c'est forcément le premier élément
// if (tabb(1) == NULL)
// tabb(1) = new FrontSegLine(tab_noeud,doCoPS1->tab_ddl);
//
// // mise à jour des indicateurs
// ind_front_point = 1;
// }
//
// return tabb;
};
};
//// ramène la frontière point
// // éventuellement création des frontieres points de l'element et stockage dans l'element
// // si c'est la première fois sinon il y a seulement retour de l'elements
// // a moins que le paramètre force est mis a true
// // dans ce dernier cas la frontière effacéee est recréée
// // num indique le numéro du point à créer (numérotation EF)
// ElFrontiere* const PoutSimple1::Frontiere_points(int,bool )
// { cout << "\n fonction non implante !! "
// << "\n PoutSimple1::Frontiere_points(..";
// Sortie(1);
// return NULL;
// }
//
//// ramène la frontière linéique
//// éventuellement création des frontieres linéique de l'element et stockage dans l'element
//// si c'est la première fois et en 3D sinon il y a seulement retour de l'elements
//// a moins que le paramètre force est mis a true
//// dans ce dernier cas la frontière effacéee est recréée
//// num indique le numéro de l'arête à créer (numérotation EF)
//ElFrontiere* const PoutSimple1::Frontiere_lineique(int num,bool )
// { // le calcul et la création ne sont effectués qu'au premier appel
// // ou lorsque l'on veut forcer une recréation
// #ifdef MISE_AU_POINT
// if (num != 1)
// { cout << "\n *** erreur, pour les poutres simples il n'y a qu'une frontière ligne ! "
// << "\n Frontiere_lineique(int num,bool force)";
// Sortie(1);
// }
// #endif
//
// // on regarde si les frontières linéiques existent sinon on les crée
// if (ind_front_lin == 1)
// return (ElFrontiere*)tabb(1);
// else if ( ind_front_lin == 2)
// // cas où certaines frontières existent
// if (tabb(1) != NULL)
// return (ElFrontiere*)tabb(1);
// // dans tous les autres cas on construit la frontière ligne
// // on commence par dimensionner le tableau de frontière
// if (ind_front_point > 0)
// // cas où il y a des frontières points (mais pas ligne)
// // on décale le tableau
// { tabb.Change_taille(3);
// tabb(3) = tabb(2);
// tabb(2) = tabb(1);
// posi_tab_front_point = 1;
// }
// // on définit la ligne
// tabb(1) = new FrontSegLine(tab_noeud,doCoPS1->tab_ddl);
// ind_front_lin = 1; // mise à jour de l'indicateur
// // et normalement posi_tab_front_ligne = 0, car jamais changé
// return (ElFrontiere*)tabb(num);
// };
//
//
//// ramène la frontière surfacique
//// éventuellement création des frontieres surfacique de l'element et stockage dans l'element
//// si c'est la première fois sinon il y a seulement retour de l'elements
//// a moins que le paramètre force est mis a true
//// dans ce dernier cas la frontière effacéee est recréée
//// num indique le numéro de la surface à créer (numérotation EF)
//// ici normalement la fonction ne doit pas être appelée
//ElFrontiere* const PoutSimple1::Frontiere_surfacique(int ,bool )
// { cout << "\n *** erreur, pour les poutres simples il n'y a pas de frontière surface ! "
// << "\n Frontiere_surfacique(int ,bool force = false)";
// Sortie(1);
// return NULL;
// };
//

View file

@ -116,20 +116,20 @@ class PoutSimple1 : public PiPoCo
// création d'un élément de copie: utilisation de l'opérateur new et du constructeur de copie
// méthode virtuelle
Element* Nevez_copie() const { Element * el= new PoutSimple1(*this); return el;};
Element* Nevez_copie() const { Element * el= new PoutSimple1(*this); return el;};
// Surcharge de l'operateur = : realise l'egalite entre deux instances de PoutSimple1
PoutSimple1& operator= (PoutSimple1& pout);
// METHODES :
// 1) derivant des virtuelles pures
// 1) derivant des virtuelles pures
// Lecture des donnees de la classe sur fichier
void LectureDonneesParticulieres (UtilLecture *,Tableau<Noeud *> * );
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
void Info_com_Element(UtilLecture * entreePrinc,string& ordre,Tableau<Noeud *> * tabMaillageNoeud)
{ return Element::Info_com_El(2,entreePrinc,ordre,tabMaillageNoeud);};
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
void Info_com_Element(UtilLecture * entreePrinc,string& ordre,Tableau<Noeud *> * tabMaillageNoeud)
{ return Element::Info_com_El(2,entreePrinc,ordre,tabMaillageNoeud);};
// Calcul du residu local et de la raideur locale,
// pour le schema implicite
@ -145,24 +145,24 @@ class PoutSimple1 : public PiPoCo
Vecteur* CalculResidu_tdt (const ParaAlgoControle & pa)
{ return PoutSimple1::CalculResidu(true,pa);};
// Calcul de la matrice masse pour l'élément
Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) ;
// Calcul de la matrice masse pour l'élément
Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) ;
// --------- calcul dynamique ---------
// calcul de la longueur d'arrête de l'élément minimal
// divisé par la célérité la plus rapide dans le matériau
double Long_arrete_mini_sur_c(Enum_dure temps)
{ return ElemMeca::Interne_Long_arrete_mini_sur_c(temps);};
// --------- calcul dynamique ---------
// calcul de la longueur d'arrête de l'élément minimal
// divisé par la célérité la plus rapide dans le matériau
double Long_arrete_mini_sur_c(Enum_dure temps)
{ return ElemMeca::Interne_Long_arrete_mini_sur_c(temps);};
// retourne les tableaux de ddl associés aux noeuds, gere par l'element
// ce tableau et specifique a l'element
const DdlElement & TableauDdl() const ;
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// Libere la place occupee par le residu et eventuellement la raideur
// par l'appel de Libere de la classe mere et libere les differents tenseurs
@ -196,75 +196,75 @@ class PoutSimple1 : public PiPoCo
// 3) cas où l'on veut les coordonnées aux trois temps
void Point_physique(const Coordonnee& c_int,Tableau <Coordonnee> & t_co);
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
//============= lecture écriture dans base info ==========
// 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 Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
// 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 Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
// définition du nombre maxi de point d'intégration dans l'épaisseur
inline int Nb_pt_int_epai()
{ return doCoPS1->segmentL.Nbi();};
// définition du nombre maxi de point d'intégration sur la surface ou
// dans l'axe de la poutre
inline int Nb_pt_int_surf()
{ return doCoPS1->segmentH.Nbi();};
// récupération de l'épaisseur
inline double H()
{ return donnee_specif.epaisseur;};
// définition du nombre maxi de point d'intégration dans l'épaisseur
inline int Nb_pt_int_epai()
{ return doCoPS1->segmentL.Nbi();};
// définition du nombre maxi de point d'intégration sur la surface ou
// dans l'axe de la poutre
inline int Nb_pt_int_surf()
{ return doCoPS1->segmentH.Nbi();};
// récupération de l'épaisseur
inline double H()
{ return donnee_specif.epaisseur;};
// --------- calculs utils dans le cadre de la recherche du flambement linéaire
// Calcul de la matrice géométrique et initiale
ElemMeca::MatGeomInit MatricesGeometrique_Et_Initiale (const ParaAlgoControle & pa) ;
// inactive les ddl du problème primaire de mécanique
inline void Inactive_ddl_primaire()
{ElemMeca::Inact_ddl_primaire(doCoPS1->tab_ddl);};
// active les ddl du problème primaire de mécanique
inline void Active_ddl_primaire()
{ElemMeca::Act_ddl_primaire(doCoPS1->tab_ddl);};
// ajout des ddl de contraintes pour les noeuds de l'élément
inline void Plus_ddl_Sigma()
{ElemMeca::Ad_ddl_Sigma(doCoPS1->tab_ddlErr);};
// inactive les ddl du problème de recherche d'erreur : les contraintes
inline void Inactive_ddl_Sigma()
{ElemMeca::Inact_ddl_Sigma(doCoPS1->tab_ddlErr);};
// active les ddl du problème de recherche d'erreur : les contraintes
inline void Active_ddl_Sigma()
{ElemMeca::Act_ddl_Sigma(doCoPS1->tab_ddlErr);};
// active le premier ddl du problème de recherche d'erreur : SIGMA11
inline void Active_premier_ddl_Sigma()
{ElemMeca::Act_premier_ddl_Sigma();};
// inactive les ddl du problème primaire de mécanique
inline void Inactive_ddl_primaire()
{ElemMeca::Inact_ddl_primaire(doCoPS1->tab_ddl);};
// active les ddl du problème primaire de mécanique
inline void Active_ddl_primaire()
{ElemMeca::Act_ddl_primaire(doCoPS1->tab_ddl);};
// ajout des ddl de contraintes pour les noeuds de l'élément
inline void Plus_ddl_Sigma()
{ElemMeca::Ad_ddl_Sigma(doCoPS1->tab_ddlErr);};
// inactive les ddl du problème de recherche d'erreur : les contraintes
inline void Inactive_ddl_Sigma()
{ElemMeca::Inact_ddl_Sigma(doCoPS1->tab_ddlErr);};
// active les ddl du problème de recherche d'erreur : les contraintes
inline void Active_ddl_Sigma()
{ElemMeca::Act_ddl_Sigma(doCoPS1->tab_ddlErr);};
// active le premier ddl du problème de recherche d'erreur : SIGMA11
inline void Active_premier_ddl_Sigma()
{ElemMeca::Act_premier_ddl_Sigma();};
// lecture de données diverses sur le flot d'entrée
void LectureContraintes(UtilLecture * entreePrinc)
{ if (CalculResidu_t_PoutSimple1_met_abstraite == 1)
ElemMeca::LectureDesContraintes (false,entreePrinc,lesPtMecaInt.TabSigHH_t());
else
{ ElemMeca::LectureDesContraintes (true,entreePrinc,lesPtMecaInt.TabSigHH_t());
CalculResidu_t_PoutSimple1_met_abstraite = 1;
}
};
// lecture de données diverses sur le flot d'entrée
void LectureContraintes(UtilLecture * entreePrinc)
{ if (CalculResidu_t_PoutSimple1_met_abstraite == 1)
ElemMeca::LectureDesContraintes (false,entreePrinc,lesPtMecaInt.TabSigHH_t());
else
{ ElemMeca::LectureDesContraintes (true,entreePrinc,lesPtMecaInt.TabSigHH_t());
CalculResidu_t_PoutSimple1_met_abstraite = 1;
}
};
// retour des contraintes en absolu retour true si elle existe sinon false
bool ContraintesAbsolues(Tableau <Vecteur>& tabSig)
{ if (CalculResidu_t_PoutSimple1_met_abstraite == 1)
ElemMeca::ContraintesEnAbsolues(false,lesPtMecaInt.TabSigHH_t(),tabSig);
else
{ ElemMeca::ContraintesEnAbsolues(true,lesPtMecaInt.TabSigHH_t(),tabSig);
CalculResidu_t_PoutSimple1_met_abstraite = 1;
}
return true; }
// retour des contraintes en absolu retour true si elle existe sinon false
bool ContraintesAbsolues(Tableau <Vecteur>& tabSig)
{ if (CalculResidu_t_PoutSimple1_met_abstraite == 1)
ElemMeca::ContraintesEnAbsolues(false,lesPtMecaInt.TabSigHH_t(),tabSig);
else
{ ElemMeca::ContraintesEnAbsolues(true,lesPtMecaInt.TabSigHH_t(),tabSig);
CalculResidu_t_PoutSimple1_met_abstraite = 1;
}
return true; }
// ========= définition et/ou construction des frontières ===============
@ -275,30 +275,6 @@ class PoutSimple1 : public PiPoCo
// dans ce dernier cas seul les frontière effacées sont recréée
Tableau <ElFrontiere*> const & Frontiere(bool force = false);
// ramène la frontière point
// éventuellement création des frontieres points de l'element et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour de l'elements
// a moins que le paramètre force est mis a true
// dans ce dernier cas la frontière effacéee est recréée
// num indique le numéro du point à créer (numérotation EF)
// ElFrontiere* const Frontiere_points(int num,bool force = false);
// ramène la frontière linéique
// éventuellement création des frontieres linéique de l'element et stockage dans l'element
// si c'est la première fois et en 3D sinon il y a seulement retour de l'elements
// a moins que le paramètre force est mis a true
// dans ce dernier cas la frontière effacéee est recréée
// num indique le numéro de l'arête à créer (numérotation EF)
// ElFrontiere* const Frontiere_lineique(int num,bool force = false);
// ramène la frontière surfacique
// éventuellement création des frontieres surfacique de l'element et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour de l'elements
// a moins que le paramètre force est mis a true
// dans ce dernier cas la frontière effacéee est recréée
// num indique le numéro de la surface à créer (numérotation EF)
// ici normalement la fonction ne doit pas être appelée
// ElFrontiere* const Frontiere_surfacique(int ,bool force = false);
// Retourne la section de l'element
double Section (Enum_dure , const Coordonnee& )
@ -315,30 +291,30 @@ class PoutSimple1 : public PiPoCo
// Retourne la hauteur de l'element
inline double Hauteur ()
{ return donnee_specif.epaisseur; };
// les coordonnees des points d'integration dans l'epaisseur
inline double KSIepais(int i) { return doCoPS1->segmentH.KSI(i);};
// les coordonnees des points d'integration dans l'epaisseur
inline double KSIepais(int i) { return doCoPS1->segmentH.KSI(i);};
// ajout du tableau specific de ddl des noeuds de la poutre
// la procedure met a jour les ddl(relatif a l'element, c-a-d Xi)
// des noeuds constituants l'element
void ConstTabDdl();
// ajout du tableau specific de ddl des noeuds de la poutre
// la procedure met a jour les ddl(relatif a l'element, c-a-d Xi)
// des noeuds constituants l'element
void ConstTabDdl();
protected:
protected:
// ==== >>>> methodes virtuelles dérivant d'ElemMeca ============
// ramene la dimension des tenseurs contraintes et déformations de l'élément
int Dim_sig_eps() const {return 1;};
// ramene la dimension des tenseurs contraintes et déformations de l'élément
int Dim_sig_eps() const {return 1;};
// -------------------- calcul de frontières en protected -------------------
// --- fonction nécessaire pour la construction des Frontières linéiques ou surfaciques particulière à l'élément
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
virtual ElFrontiere* new_frontiere_lin(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
virtual ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{return NULL;} // il n'y a pas de surface possible
// --- fonction nécessaire pour la construction des Frontières linéiques ou surfaciques particulière à l'élément
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
virtual ElFrontiere* new_frontiere_lin(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
virtual ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{return NULL;} // il n'y a pas de surface possible
private :

View file

@ -68,20 +68,20 @@ class PiPoCo : public ElemMeca
PiPoCo (int num_mail=0,int num_id=-3) : ElemMeca (num_mail,num_id) {};
// Constructeur : un numero de maillage et d'identification et le tableau de connexite des noeuds
PiPoCo (int num_mail,int num_id,const Tableau<Noeud *>& tab) : ElemMeca (num_mail, num_id, tab) {};
// Constructeur : un numero de maillage, d'identification ,la geometrie ,le type d'interpolation
PiPoCo (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt) :
ElemMeca (num_mail,num_id,id_interp_elt,id_geom_elt) {};
// Constructeur idem si-dessus mais des chaines de caractères
PiPoCo (int num_mail,int num_id,char* nom_interpol,char* nom_geom) :
ElemMeca (num_mail,num_id,nom_interpol,nom_geom) {};
// Constructeur utile quand toutes les donnees de la classe Element sont connues
// 1) avec des identificateurs d'énumétation
PiPoCo (int num_mail,int num_id,const Tableau<Noeud *>& tab,Enum_interpol id_interp_elt,
Enum_geom id_geom_elt) :
ElemMeca (num_mail,num_id,tab,id_interp_elt,id_geom_elt) {};
// 2) avec des identificateurs = chaines de caractères
PiPoCo (int num_mail,int num_id,const Tableau<Noeud *>& tab,char* nom_interpol,char* nom_geom) :
ElemMeca (num_mail,num_id,tab,nom_interpol,nom_geom) {} ;
// Constructeur : un numero de maillage, d'identification ,la geometrie ,le type d'interpolation
PiPoCo (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt) :
ElemMeca (num_mail,num_id,id_interp_elt,id_geom_elt) {};
// Constructeur idem si-dessus mais des chaines de caractères
PiPoCo (int num_mail,int num_id,char* nom_interpol,char* nom_geom) :
ElemMeca (num_mail,num_id,nom_interpol,nom_geom) {};
// Constructeur utile quand toutes les donnees de la classe Element sont connues
// 1) avec des identificateurs d'énumétation
PiPoCo (int num_mail,int num_id,const Tableau<Noeud *>& tab,Enum_interpol id_interp_elt,
Enum_geom id_geom_elt) :
ElemMeca (num_mail,num_id,tab,id_interp_elt,id_geom_elt) {};
// 2) avec des identificateurs = chaines de caractères
PiPoCo (int num_mail,int num_id,const Tableau<Noeud *>& tab,char* nom_interpol,char* nom_geom) :
ElemMeca (num_mail,num_id,tab,nom_interpol,nom_geom) {} ;
// Constructeur de copie
PiPoCo (const PiPoCo& ps) : ElemMeca (ps) {};
@ -90,32 +90,32 @@ class PiPoCo : public ElemMeca
// =========================== methodes publiques ===============================
// ramene vrai si la surface numéro ns existe pour l'élément
// dans le cas des poutres il n'y a pas de surface
bool SurfExiste(int ) const
// ramene vrai si la surface numéro ns existe pour l'élément
// dans le cas des poutres il n'y a pas de surface
bool SurfExiste(int ) const
{ return false;};
// ramene vrai si l'arête numéro na existe pour l'élément
bool AreteExiste(int na) const {if (na==1) return true; else return false;};
// ramene vrai si l'arête numéro na existe pour l'élément
bool AreteExiste(int na) const {if (na==1) return true; else return false;};
// calcul si un point est a l'interieur de l'element ou non
// il faut que M est la dimension globale
// les trois fonctions sont pour l'etude a t=0, t et tdt
// retour : =0 le point est externe, =1 le point est interne ,
// = 2 le point est sur la frontière à la précision près
// coor_locales : s'il est différent de NULL, est affecté des coordonnées locales calculées,
// uniquement précises si le point est interne
int Interne_0(const Coordonnee& M,Coordonnee* coor_locales=NULL);
int Interne_t(const Coordonnee& M,Coordonnee* coor_locales=NULL);
int Interne_tdt(const Coordonnee& M,Coordonnee* coor_locales=NULL);
//1) methodes virtuelles
// définition du nombre maxi de point d'intégration dans l'épaisseur
virtual int Nb_pt_int_epai() = 0;
// définition du nombre maxi de point d'intégration sur la surface ou
// dans l'axe de la poutre
virtual int Nb_pt_int_surf() = 0;
// récupération de l'épaisseur
virtual double H() = 0;
// calcul si un point est a l'interieur de l'element ou non
// il faut que M est la dimension globale
// les trois fonctions sont pour l'etude a t=0, t et tdt
// retour : =0 le point est externe, =1 le point est interne ,
// = 2 le point est sur la frontière à la précision près
// coor_locales : s'il est différent de NULL, est affecté des coordonnées locales calculées,
// uniquement précises si le point est interne
int Interne_0(const Coordonnee& M,Coordonnee* coor_locales=NULL);
int Interne_t(const Coordonnee& M,Coordonnee* coor_locales=NULL);
int Interne_tdt(const Coordonnee& M,Coordonnee* coor_locales=NULL);
//1) methodes virtuelles
// définition du nombre maxi de point d'intégration dans l'épaisseur
virtual int Nb_pt_int_epai() = 0;
// définition du nombre maxi de point d'intégration sur la surface ou
// dans l'axe de la poutre
virtual int Nb_pt_int_surf() = 0;
// récupération de l'épaisseur
virtual double H() = 0;
// ------- affichage ou récupération d'informations --------------
// retourne un numero d'ordre d'un point le plus près ou est exprimé la grandeur enum
@ -127,74 +127,76 @@ class PiPoCo : public ElemMeca
{// méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::PointLePlusPres(Enum_dure...";
Sortie(1);
return PtLePlusPres(temps,enu,M);};
return PtLePlusPres(temps,enu,M);
};
// recuperation des coordonnées du point de numéro d'ordre iteg pour
// la grandeur enu
// recuperation des coordonnées du point de numéro d'ordre iteg pour
// la grandeur enu
// temps: dit si c'est à 0 ou t ou tdt
// si erreur retourne erreur à true
Coordonnee CoordPtInteg(Enum_dure temps,Enum_ddl enu,int iteg,bool& erreur)
// si erreur retourne erreur à true
Coordonnee CoordPtInteg(Enum_dure temps,Enum_ddl enu,int iteg,bool& erreur)
{// méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::CoordPtInteg(Enum_dure...";
Sortie(1);
return CoordPtInt(temps,enu,iteg,erreur);};
return CoordPtInt(temps,enu,iteg,erreur);
};
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau <double> Valeur_a_diff_temps(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu,int iteg) { // méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::Valeur_a_diff_temps(Enum_dure...";
Sortie(1);
return ElemMeca::Valeur_multi(absolue,enu_t,enu,iteg,1); // "
};
// récupération des valeurs au numéro d'ordre = iteg pour les grandeurs enu
// ici il s'agit de grandeurs tensorielles, le retour s'effectue dans la liste
// de conteneurs quelconque associée
void ValTensorielle_a_diff_temps(bool absolue,Enum_dure ,List_io<TypeQuelconque>& ,int )
{ // méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::ValTensorielle_a_diff_temps(Enum_dure...";
Sortie(1);
};
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau <double> Valeur_a_diff_temps(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu,int iteg) { // méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::Valeur_a_diff_temps(Enum_dure...";
Sortie(1);
return ElemMeca::Valeur_multi(absolue,enu_t,enu,iteg,1); // "
};
// récupération des valeurs au numéro d'ordre = iteg pour les grandeurs enu
// ici il s'agit de grandeurs tensorielles, le retour s'effectue dans la liste
// de conteneurs quelconque associée
void ValTensorielle_a_diff_temps(bool absolue,Enum_dure ,List_io<TypeQuelconque>& ,int )
{ // méthode ici à faire, car ici spécifique au fait d'avoir des pt d'integ dans l'épaisseur
cout << "\n non implanté , PiPoCo::ValTensorielle_a_diff_temps(Enum_dure...";
Sortie(1);
};
// 2) methodes découlant de virtuelles
// --------- calculs utils dans le cadre de la recherche du flambement linéaire
// Calcul de la matrice géométrique et initiale
ElemMeca::MatGeomInit MatricesGeometrique_Et_Initiale (const ParaAlgoControle & pa);
// 2) methodes découlant de virtuelles
// --------- calculs utils dans le cadre de la recherche du flambement linéaire
// Calcul de la matrice géométrique et initiale
ElemMeca::MatGeomInit MatricesGeometrique_Et_Initiale (const ParaAlgoControle & pa);
// 3) methodes propres a l'element
// les coordonnees des points d'integration dans l'epaisseur
// 3) methodes propres a l'element
// les coordonnees des points d'integration dans l'epaisseur
virtual double KSIepais(int i) =0;
// ========= methodes protégées utilisables par les classes derivees :======================
protected :
// 4) non virtuelles
// Calcul du residu local et de la raideur locale, pour le schema implicite
// cald_Dvirtuelle = indique si l'on doit calculer la dérivée de la vitesse de déformation virtuelle
void Cal_implicitPiPoCo (DdlElement & tab_ddl,Tableau <TenseurBB *> & d_epsBB
// 4) non virtuelles
// Calcul du residu local et de la raideur locale, pour le schema implicite
// cald_Dvirtuelle = indique si l'on doit calculer la dérivée de la vitesse de déformation virtuelle
void Cal_implicitPiPoCo (DdlElement & tab_ddl,Tableau <TenseurBB *> & d_epsBB
,Tableau < Tableau2 <TenseurBB *> > d2_epsBB,Tableau <TenseurHH *> & d_sigHH
,int nbintS,Vecteur& poidsS,int nbintH,Vecteur& poidsH
,const ParaAlgoControle & pa,bool cald_Dvirtuelle);
// Calcul du residu local a l'instant t ou tdt
// atdt = true : calcul à tdt, valeur par défaut
// = false: calcul à t
void Cal_explicitPiPoCo (DdlElement & tab_ddl,Tableau <TenseurBB *> & d_epsBB,int nbintS
// Calcul du residu local a l'instant t ou tdt
// atdt = true : calcul à tdt, valeur par défaut
// = false: calcul à t
void Cal_explicitPiPoCo (DdlElement & tab_ddl,Tableau <TenseurBB *> & d_epsBB,int nbintS
,Vecteur& poidsS,int nbintH,Vecteur& poidsH,const ParaAlgoControle & pa,bool atdt);
// Calcul de la matrice géométrique et de la matrice initiale
// cette fonction est éventuellement appelée par les classes dérivées
// ddl represente les degres de liberte specifiques a l'element
// epsBB = deformation, sigHH = contrainte, d_epsbb = variation des def
// nbint = nb maxi de pt d'integration , poids = poids d'integration
// S pour surface et H pour épaisseur -> nbint et poids
// cald_Dvirtuelle = indique si l'on doit calculer la dérivée de la vitesse de déformation virtuelle
void Cal_matGeom_InitPiPoCo (Mat_pleine & matGeom, Mat_pleine & matInit,DdlElement & tab_ddl
// Calcul de la matrice géométrique et de la matrice initiale
// cette fonction est éventuellement appelée par les classes dérivées
// ddl represente les degres de liberte specifiques a l'element
// epsBB = deformation, sigHH = contrainte, d_epsbb = variation des def
// nbint = nb maxi de pt d'integration , poids = poids d'integration
// S pour surface et H pour épaisseur -> nbint et poids
// cald_Dvirtuelle = indique si l'on doit calculer la dérivée de la vitesse de déformation virtuelle
void Cal_matGeom_InitPiPoCo (Mat_pleine & matGeom, Mat_pleine & matInit,DdlElement & tab_ddl
,Tableau <TenseurBB *>& d_epsBB, Tableau < Tableau2 <TenseurBB *> > d2_epsBB
,Tableau <TenseurHH *> & d_sigHH,int nbintS,Vecteur& poidsS,int nbintH,Vecteur& poidsH
,const ParaAlgoControle & pa,bool cald_Dvirtuelle);
private: // pour éviter les modifications par les classes dérivées
private: // pour éviter les modifications par les classes dérivées
static TenseurHH * sig_bulk_pourPiPoCo_HH; // variable de travail pour le bulk
};

View file

@ -99,18 +99,18 @@ PentaL::PentaL () :
};
int dim = ParaGlob::Dimension();
if (dim != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements pentaedriques lineaires "<< endl;
delete penta;delete pentaEr;delete pentaMas;delete pentaeHourg;
unefois = NULL;
}
else
// après penta on défini les données relatives aux surfaces externes (frontières)
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoPentaL = PentaMemb::Init (penta,pentaEr,pentaMas,pentaeHourg);
unefois->nbelem_in_Prog++;
}
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements pentaedriques lineaires "<< endl;
delete penta;delete pentaEr;delete pentaMas;delete pentaeHourg;
unefois = NULL;
}
else
// après penta on défini les données relatives aux surfaces externes (frontières)
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoPentaL = PentaMemb::Init (penta,pentaEr,pentaMas,pentaeHourg);
unefois->nbelem_in_Prog++;
}
};
};
@ -127,28 +127,28 @@ PentaL::PentaL (int num_maill,int num_id) :
tab_noeud.Change_taille(nombre->nbne);
// calcul de doCoPentaL si c'est le premier passage
ElemGeomC0* penta=NULL;ElemGeomC0* pentaEr=NULL; ElemGeomC0* pentaMas=NULL;
ElemGeomC0* pentaeHourg=NULL; // pour le blocage d'hourglass
ElemGeomC0* pentaeHourg=NULL; // pour le blocage d'hourglass
if ( doCoPentaL == NULL)
{penta = new GeomPentaL(nombre->nbI);
// pour le calcul d'erreur il faut au moins autant de points d'intégration que de noeuds
pentaEr = new GeomPentaL(nombre->nbiEr);
// idem pour le calcul de la matrice masse consistante
pentaMas = new GeomPentaL(nombre->nbiMas);
pentaeHourg = new GeomPentaL(nombre->nbiHour);
}
// pour le calcul d'erreur il faut au moins autant de points d'intégration que de noeuds
pentaEr = new GeomPentaL(nombre->nbiEr);
// idem pour le calcul de la matrice masse consistante
pentaMas = new GeomPentaL(nombre->nbiMas);
pentaeHourg = new GeomPentaL(nombre->nbiHour);
};
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans PentaL, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans PentaL, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
}
#endif
// après penta on défini les données relatives aux surfaces externes (frontières)
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoPentaL = PentaMemb::Init (penta,pentaEr,pentaMas,pentaeHourg);
unefois->nbelem_in_Prog++;
}
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoPentaL = PentaMemb::Init (penta,pentaEr,pentaMas,pentaeHourg);
unefois->nbelem_in_Prog++;
}
};
};
@ -159,34 +159,35 @@ PentaL::PentaL (int num_maill,int num_id,const Tableau<Noeud *>& tab):
{// on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
}
else // sinon on construit
{nombre = & nombre_V;
if (tab_noeud.Taille() != nombre->nbne)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " PentaL::PentaL (double epaiss,int num_maill, int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " PentaL::PentaL (double epaiss,int num_maill, int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1);
}
// calcul de doCoPentaL si c'est le premier passage
ElemGeomC0* penta=NULL;ElemGeomC0* pentaEr=NULL; ElemGeomC0* pentaMas=NULL;
ElemGeomC0* pentaeHourg=NULL; // pour le blocage d'hourglass
ElemGeomC0* pentaeHourg=NULL; // pour le blocage d'hourglass
if ( doCoPentaL == NULL)
{penta = new GeomPentaL(nombre->nbI);
// pour le calcul d'erreur il faut au moins autant de points d'intégration que de noeuds
pentaEr = new GeomPentaL(nombre->nbiEr);
// idem pour le calcul de la matrice masse consistante
pentaMas = new GeomPentaL(nombre->nbiMas);
pentaeHourg = new GeomPentaL(nombre->nbiHour);
}
// pour le calcul d'erreur il faut au moins autant de points d'intégration que de noeuds
pentaEr = new GeomPentaL(nombre->nbiEr);
// idem pour le calcul de la matrice masse consistante
pentaMas = new GeomPentaL(nombre->nbiMas);
pentaeHourg = new GeomPentaL(nombre->nbiHour);
};
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans PentaL, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
cout << "\n erreur de dimension dans PentaL, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
#endif
// après penta on défini les données relatives aux surfaces externes (frontières)
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoPentaL = PentaMemb::Init (penta,pentaEr,pentaMas,pentaeHourg,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
@ -203,15 +204,15 @@ PentaL::PentaL (const PentaL& PentaLraM) :
// a priori si on utilise le constructeur de copie, donc il y a déjà un élément
// par contre a priori on ne doit pas faire une copie du premier élément
{ if (uneFois.nbelem_in_Prog == 1)
{ cout << "\n **** erreur pour l'element PentaL, le constructeur de copie ne doit pas etre utilise"
<< " pour le premier element !! " << endl;
Sortie (1);
{ cout << "\n **** erreur pour l'element PentaL, le constructeur de copie ne doit pas etre utilise"
<< " pour le premier element !! " << endl;
Sortie (1);
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique penta
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique penta
// ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et PentaMemb
unefois->nbelem_in_Prog++;
};
unefois->nbelem_in_Prog++;
};
};
PentaL::~PentaL ()
@ -219,7 +220,7 @@ PentaL::~PentaL ()
{ if (unefois != NULL)
{unefois->nbelem_in_Prog--;
Destruction();
}
}
};
// affichage dans la sortie transmise, des variables duales "nom"

View file

@ -113,69 +113,69 @@ class PentaL : public PentaMemb
// création d'un élément de copie: utilisation de l'opérateur new et du constructeur de copie
// méthode virtuelle
Element* Nevez_copie() const { Element * el= new PentaL(*this); return el;};
Element* Nevez_copie() const { Element * el= new PentaL(*this); return el;};
// Surcharge de l'operateur = : realise l'egalite entre deux instances de PentaL
PentaL& operator= (PentaL& Penta);
// METHODES :
// 1) derivant des virtuelles pures
// 1) derivant des virtuelles pures
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
// 2) derivant des virtuelles
// 3) methodes propres a l'element
// 2) derivant des virtuelles
// 3) methodes propres a l'element
protected :
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
// frontière linéique verticale (rectangle)
ElFrontiere* new_frontiere_lin_rec(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
// frontière linéique horizontale (triangle)
ElFrontiere* new_frontiere_lin_tri(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
// frontière surfacique verticale (rectangle)
ElFrontiere* new_frontiere_surf_rec(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// frontière surfacique horizontale (triangle)
ElFrontiere* new_frontiere_surf_tri(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontTriaLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements PentaL
static PentaMemb::DonnComPenta * doCoPentaL;
// idem mais pour les indicateurs qui servent pour l'initialisation
static PentaMemb::UneFois uneFois;
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
// frontière linéique verticale (rectangle)
ElFrontiere* new_frontiere_lin_rec(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
// frontière linéique horizontale (triangle)
ElFrontiere* new_frontiere_lin_tri(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontSegLine(tab,ddelem)));};
// frontière surfacique verticale (rectangle)
ElFrontiere* new_frontiere_surf_rec(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// frontière surfacique horizontale (triangle)
ElFrontiere* new_frontiere_surf_tri(Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontTriaLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements PentaL
static PentaMemb::DonnComPenta * doCoPentaL;
// idem mais pour les indicateurs qui servent pour l'initialisation
static PentaMemb::UneFois uneFois;
class NombresConstruirePentaL : public NombresConstruire
class NombresConstruirePentaL : public NombresConstruire
{ public: NombresConstruirePentaL();
};
static NombresConstruirePentaL nombre_V; // les nombres propres à l'élément
static NombresConstruirePentaL nombre_V; // les nombres propres à l'élément
// GESTION AUTOMATIQUE D'AJOUT D'ELEMENT DANS LE PROGRAMME
//ajout de l'element dans la liste : listTypeElemen, geree par la class Element
class ConsPentaL : public ConstrucElement
{ public : ConsPentaL ()
{ NouvelleTypeElement nouv(PENTAEDRE,LINEAIRE,MECA_SOLIDE_DEFORMABLE,this);
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n initialisation PentaL" << endl;
Element::listTypeElement.push_back(nouv);
};
Element * NouvelElement(int num_maill,int num) // un nouvel élément sans rien
{Element * pt;
pt = new PentaL (num_maill,num) ;
return pt;};
// ramene true si la construction de l'element est possible en fonction
// des variables globales actuelles: ex en fonction de la dimension
bool Element_possible() { if (ParaGlob::Dimension() == 3) return true; else return false;};
};
static ConsPentaL consPentaL;
static int bidon; // a virer lorsque l'on n'aura plus a declarer une instance dans herezh
// GESTION AUTOMATIQUE D'AJOUT D'ELEMENT DANS LE PROGRAMME
//ajout de l'element dans la liste : listTypeElemen, geree par la class Element
class ConsPentaL : public ConstrucElement
{ public : ConsPentaL ()
{ NouvelleTypeElement nouv(PENTAEDRE,LINEAIRE,MECA_SOLIDE_DEFORMABLE,this);
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n initialisation PentaL" << endl;
Element::listTypeElement.push_back(nouv);
};
Element * NouvelElement(int num_maill,int num) // un nouvel élément sans rien
{Element * pt;
pt = new PentaL (num_maill,num) ;
return pt;};
// ramene true si la construction de l'element est possible en fonction
// des variables globales actuelles: ex en fonction de la dimension
bool Element_possible() { if (ParaGlob::Dimension() == 3) return true; else return false;};
};
static ConsPentaL consPentaL;
static int bidon; // a virer lorsque l'on n'aura plus a declarer une instance dans herezh
};
/// @} // end of group
#endif

View file

@ -583,8 +583,8 @@ void PentaMemb::ErreurElement(int type,double& errElemRelative
,double& numerateur, double& denominateur)
{ PentaMemb::DonnComPenta* doCoPenta = unefois->doCoMemb; // pour simplifier l'écriture
Tableau <TenseurBB *>& d_epsBB = unefois->doCoMemb->d_epsBB;
Tableau <TenseurHH *>& d_sigHH = unefois->doCoMemb->d_sigHH;
// Tableau <TenseurBB *>& d_epsBB = unefois->doCoMemb->d_epsBB;
// Tableau <TenseurHH *>& d_sigHH = unefois->doCoMemb->d_sigHH;
// dimensionnement de la metrique
if(!( unefois->CalResPrem_t ))
{ unefois->CalResPrem_t += 1;
@ -802,47 +802,49 @@ Element::ResRaid PentaMemb::SMR_charge_surfacique_I
// explicite à t et à tdt en fonction de la variable booléeenne atdt
Vecteur PentaMemb::SM_charge_pression_E
(double pression,Fonction_nD* pt_fonct,int numface,bool atdt,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu
{ // initialisation du vecteur résidu
((*res_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique, si elle n'existe pas il faut la creer d'ou le true
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
// avec l'instance déformation dédiée pour
// récupération de la métrique associée à l'élément
Met_abstraite * meta= tabb(numface)->Metrique();
Met_abstraite * meta= tabb(numface)->Metrique();
PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// définition des constantes de la métrique si nécessaire
if (!atdt)
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};}
else
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};};
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};
}
else
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};
};
// définition d'une déformation a doc
if (defSurf(numface) == NULL)
{if ((numface == 1) || (numface == 4))
// les faces 1 et 4 sont triangulaire
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->triaS).TaDphi(),(CoPenta->triaS).TaPhi());
else // les autres surfaces sont quadrangulaires
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->quadraS).TaDphi(),(CoPenta->quadraS).TaPhi());
};
{if ((numface == 1) || (numface == 4))
// les faces 1 et 4 sont triangulaire
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->triaS).TaDphi(),(CoPenta->triaS).TaPhi());
else // les autres surfaces sont quadrangulaires
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->quadraS).TaDphi(),(CoPenta->quadraS).TaPhi());
};
// appel du programme général d'elemmeca et retour du vecteur second membre
if ((numface == 1) || (numface == 4))
return ElemMeca::SM_charge_pres_E (tabb(numface)->DdlElem(),numface
@ -865,9 +867,9 @@ Vecteur PentaMemb::SM_charge_pression_E
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid PentaMemb::SMR_charge_pression_I
(double pression,Fonction_nD* pt_fonct,int numface,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique, si elle n'existe pas il faut la creer d'ou le true
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -878,7 +880,7 @@ Element::ResRaid PentaMemb::SMR_charge_pression_I
PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// dimensionnement de la metrique
// définition des constantes de la métrique si nécessaire
if ( !(unefois->CalSMRsurf(numface) ))
if ( !(unefois->CalSMRsurf(numface) ))
{ unefois->CalSMRsurf(numface) += 1;
Tableau<Enum_variable_metrique> tab(20);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igiB_tdt; tab(4) = igijBB_0;
@ -888,17 +890,17 @@ Element::ResRaid PentaMemb::SMR_charge_pression_I
tab(15) = id_gijBB_t ;tab(16) = id_gijBB_tdt ;tab(17) = idMtdt ;
tab(18) = igradVBB_tdt; tab(19) = iVtdt; tab(20) = idVtdt;
meta->PlusInitVariables(tab) ;
};
};
// définition d'une déformation a doc
if (defSurf(numface) == NULL)
{if ((numface == 1) || (numface == 4))
// les faces 1 et 4 sont triangulaire
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->triaS).TaDphi(),(CoPenta->triaS).TaPhi());
else // les autres surfaces sont quadrangulaires
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->quadraS).TaDphi(),(CoPenta->quadraS).TaPhi());
};
{if ((numface == 1) || (numface == 4))
// les faces 1 et 4 sont triangulaire
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->triaS).TaDphi(),(CoPenta->triaS).TaPhi());
else // les autres surfaces sont quadrangulaires
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
(CoPenta->quadraS).TaDphi(),(CoPenta->quadraS).TaPhi());
};
// appel du programme général d'elemmeca et retour du vecteur second membre
if ((numface == 1) || (numface == 4))
return ElemMeca::SMR_charge_pres_I (tabb(numface)->DdlElem(),numface
@ -918,8 +920,8 @@ Element::ResRaid PentaMemb::SMR_charge_pression_I
Vecteur PentaMemb::SM_charge_presUniDir_E
(const Coordonnee& presUniDir,Fonction_nD* pt_fonct
,int numface,bool atdt,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu
((*res_extS)(numface))->Zero();
{ // initialisation du vecteur résidu
((*res_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -930,25 +932,27 @@ Vecteur PentaMemb::SM_charge_presUniDir_E
PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// définition des constantes de la métrique si nécessaire
if (!atdt)
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};}
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};
}
else
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};};
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};
};
// définition d'une déformation a doc
if (defSurf(numface) == NULL)
{if ((numface == 1) || (numface == 4))
@ -975,9 +979,9 @@ Vecteur PentaMemb::SM_charge_presUniDir_E
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid PentaMemb::SMR_charge_presUniDir_I
(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numface,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -1165,29 +1169,31 @@ Vecteur PentaMemb::SM_charge_hydrostatique_E(const Coordonnee& dir_normal_liquid
// on utilise la métrique des éléments de frontière
// avec l'instance déformation dédiée pour
// récupération de la métrique associée à l'élément
Met_abstraite * meta= tabb(numface)->Metrique();
Met_abstraite * meta= tabb(numface)->Metrique();
PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// définition des constantes de la métrique si nécessaire
if (!atdt)
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};}
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};
}
else
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};};
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};
};
// définition d'une déformation a doc
if (defSurf(numface) == NULL)
{if ((numface == 1) || (numface == 4))
@ -1228,9 +1234,9 @@ Element::ResRaid PentaMemb::SMR_charge_hydrostatique_I (const Coordonnee& dir_no
,int numface,const Coordonnee& M_liquide
,const ParaAlgoControle & pa
,bool sans_limitation)
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -1287,8 +1293,8 @@ Vecteur PentaMemb::SM_charge_hydrodynamique_E( Courbe1D* frot_fluid,const doubl
, Courbe1D* coef_aero_n,int numface,const double& coef_mul
, Courbe1D* coef_aero_t,bool atdt
,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu
((*res_extS)(numface))->Zero();
{ // initialisation du vecteur résidu
((*res_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -1298,25 +1304,27 @@ Vecteur PentaMemb::SM_charge_hydrodynamique_E( Courbe1D* frot_fluid,const doubl
PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// définition des constantes de la métrique si nécessaire
if (!atdt)
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};}
{if ( !(unefois->CalSMsurf_t(numface) ))
{ unefois->CalSMsurf_t(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t;
tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_t; tab(11) = iVt;
meta->PlusInitVariables(tab) ;
};
}
else
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};};
{if ( !(unefois->CalSMsurf_tdt(numface) ))
{ unefois->CalSMsurf_tdt(numface) += 1;
Tableau<Enum_variable_metrique> tab(11);
tab(1) = igiB_0; tab(2) = igiB_tdt; tab(3) = igijBB_0;tab(4) = igijBB_tdt;
tab(5) = igijHH_tdt; tab(6) = id_giB_tdt; tab(7) = id_gijBB_tdt ;
tab(8) = id_gijBB_t ;tab(9) = id_gijBB_tdt ;
tab(10) = igradVBB_tdt;tab(11) = iVtdt;
meta->PlusInitVariables(tab) ;
};
};
// définition d'une déformation a doc
ElemGeomC0* elemGeom;
if (defSurf(numface) == NULL)
@ -1326,23 +1334,23 @@ Vecteur PentaMemb::SM_charge_hydrodynamique_E( Courbe1D* frot_fluid,const doubl
{ elemGeom = & (CoPenta->triaS);};
defSurf(numface) = new Deformation(*meta,tabb(numface)->TabNoeud(),
elemGeom->TaDphi(),elemGeom->TaPhi());
};
};
// appel du programme général d'ElemMeca et retour du vecteur second membre
return ElemMeca::SM_charge_hydrodyn_E (poidvol,elemGeom->TaPhi(),(tabb(numface)->TabNoeud()).Taille()
,frot_fluid,elemGeom->TaWi()
,coef_aero_n,numface,coef_mul,coef_aero_t,pa,atdt);
};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
Element::ResRaid PentaMemb::SMR_charge_hydrodynamique_I( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numface,const double& coef_mul
, Courbe1D* coef_aero_t
,const ParaAlgoControle & pa)
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
{ // initialisation du vecteur résidu et de la raideur
((*res_extS)(numface))->Zero();
((*raid_extS)(numface))->Zero();
// on récupère ou on crée la frontière surfacique
Frontiere_surfacique(numface,true);
// on utilise la métrique des éléments de frontière
@ -1401,199 +1409,12 @@ Tableau <ElFrontiere*> const & PentaMemb::Frontiere(bool force)
// on s'occupe également des indicateurs
unefois->CalSMsurf_t.Change_taille(tail_fa);unefois->CalSMsurf_tdt.Change_taille(tail_fa);
unefois->CalSMRsurf.Change_taille(tail_fa);
};
};
// {// le calcul et la création ne sont effectués qu'au premier appel
// // ou lorsque l'on veut forcer une recréation
// if (((ind_front_lin == 0) && (ind_front_surf == 0) && (ind_front_point == 0))
// || force )
//// if ( (ind_front_surf==0)|| force ||(ind_front_surf==2) )
// {PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// ElemGeomC0 & el = *(CoPenta->pentaed);
// DdlElement & tdd = CoPenta->tab_ddl;
// int tail_s = el.Nonf().Taille(); // nombre de faces
// // def de la taille
// if (((ind_front_point > 0) || (ind_front_lin > 0)) && (ind_front_surf == 0))
// // cas où les frontières points ou linéiques existent mais pas les frontières faces
// // on redimentionne et on transfert
// { int tail_af = nombre->nbne+el.NonS().Taille(); // nombre d'arête + noeud
// int taille_f = tail_af + tail_s;
// tabb.Change_taille(taille_f);
// // on s'occupe également des indicateurs
// unefois->CalSMsurf_t.Change_taille(taille_f);unefois->CalSMsurf_tdt.Change_taille(taille_f);
// unefois->CalSMRsurf.Change_taille(taille_f);
// for (int i=1;i<= tail_af;i++)
// { tabb(i+tail_s) = tabb(i);tabb(i) = NULL;
// unefois->CalSMsurf_t(i+tail_s)=unefois->CalSMsurf_t(i);
// unefois->CalSMsurf_tdt(i+tail_s)=unefois->CalSMsurf_tdt(i);
// unefois->CalSMRsurf(i+tail_s)=unefois->CalSMRsurf(i);
// unefois->CalSMsurf_t(i)=0;unefois->CalSMsurf_tdt(i)=0;unefois->CalSMRsurf(i)=0;
// }
// posi_tab_front_lin += tail_s;
// posi_tab_front_point += tail_s;
// }
// else if (ind_front_surf == 0)
// // cas où rien n'existe
// {tabb.Change_taille(tail_s);
// // on s'occupe également des indicateurs
// unefois->CalSMsurf_t.Change_taille(tail_s);unefois->CalSMsurf_tdt.Change_taille(tail_s);
// unefois->CalSMRsurf.Change_taille(tail_s);
// }
// // création éventuelle des faces
// for (int nface=1;nface<=tail_s;nface++)
// { int nbnoe = el.Nonf()(nface).Taille(); // nb noeud de la face
// Tableau <Noeud *> tab(nbnoe); // les noeuds des faces frontieres
// DdlElement ddelem(nbnoe); // les ddlelements des noeuds frontieres
// for (int i=1;i<= nbnoe;i++)
// { int nib=el.Nonf()(nface)(i); // numéro dans l'élément du numéro i de la face
// tab(i) = tab_noeud(nib);
// DdlNoeudElement einter = tdd(nib);
// ddelem.Change_un_ddlNoeudElement(i,einter);
// // ddelem(i) = tdd(el.Nonf()(nface)(i));
// }
// if ((nface == 1) || (nface == 4))
// // les faces 1 et 4 sont triangulaire
// {if (tabb(nface) == NULL) tabb(nface) = new_frontiere_surf_tri(tab,ddelem);}
// else
// // les faces 2,3 et 5 sont quadrangulaire
// {if (tabb(nface) == NULL) tabb(nface) = new_frontiere_surf_rec(tab,ddelem); }
// }
// // mise à jour de l'indicateur de création de faces
// ind_front_surf = 1;
// }
return (Tableau <ElFrontiere*>&)tabb;
};
//// ramène la frontière point
//// éventuellement création des frontieres points de l'element et stockage dans l'element
//// si c'est la première fois sinon il y a seulement retour de l'elements
//// a moins que le paramètre force est mis a true
//// dans ce dernier cas la frontière effacéee est recréée
//// num indique le numéro du point à créer (numérotation EF)
//ElFrontiere* const PentaMemb::Frontiere_points(int num,bool force)
// { // le calcul et la création ne sont effectués qu'au premier appel
// // ou lorsque l'on veut forcer une recréation
// #ifdef MISE_AU_POINT
// if ((num > nombre->nbne)||(num <=0))
// { cout << "\n *** erreur, le noeud demande pour frontiere: " << num << " esten dehors de la numeration de l'element ! "
// << "\n Frontiere_points(int num,bool force)";
// Sortie(1);
// }
// #endif
//
// if ((ind_front_point == 0) || force || (ind_front_point == 2))
// {Tableau <Noeud *> tab(1); // les noeuds des points frontieres
// DdlElement ddelem(1); // les ddlelements des points frontieres
// // on regarde si les frontières points existent sinon on les crée
// if (ind_front_point == 1)
// return (ElFrontiere*)tabb(posi_tab_front_point+num);
// else if ( ind_front_point == 2)
// // cas où certaines frontières existent
// if (tabb(posi_tab_front_point+num) != NULL)
// return (ElFrontiere*)tabb(posi_tab_front_point+num);
// // dans tous les autres cas on construit la frontière point
// // on commence par dimensionner le tableau de frontière, comme les frontières points sont
// // les dernières, il suffit de les ajouter, d'où on redimentionne le tableau mais on ne créra
// // que la frontière adoc
// // def de la taille
// int taille_actuelle = tabb.Taille();
// if ((ind_front_point == 0) && ((ind_front_lin > 0) || (ind_front_surf > 0)))
// // cas où les frontières lignes ou surfaces existent, mais pas les points
// { int tail_p = nombre->nbne; // le nombre de noeuds
// int taille_f = taille_actuelle + tail_p;
// tabb.Change_taille(taille_f);
// for (int i=1;i<= tail_p;i++)
// { tabb(i+taille_actuelle) = tabb(i);tabb(i) = NULL;};
// posi_tab_front_point +=taille_actuelle;
// if (ind_front_lin > 0) posi_tab_front_lin += taille_actuelle;
// }
// else if (ind_front_point == 0)
// // cas où aucune frontière n'existe
// {tabb.Change_taille(nombre->nbne);};
// // dans les autres cas, les frontières points exitent donc pas à dimensionner
// // on définit tous les points par simplicité
// for (int i=1;i<=nombre->nbne;i++)
// {tab(1) = tab_noeud(i);ddelem.Change_un_ddlNoeudElement(1,unefois->doCoMemb->tab_ddl(i));
// if (tabb(i+posi_tab_front_point) == NULL)
// tabb(i+posi_tab_front_point) = new FrontPointF (tab,ddelem);
// };
// };
// return (ElFrontiere*)tabb(num+posi_tab_front_point);
// };
//// ramène la frontière linéique
//// éventuellement création des frontieres linéique de l'element et stockage dans l'element
//// si c'est la première fois et en 3D sinon il y a seulement retour de l'elements
//// a moins que le paramètre force est mis a true
//// dans ce dernier cas la frontière effacéee est recréée
//// num indique le numéro de l'arête à créer (numérotation EF)
//ElFrontiere* const PentaMemb::Frontiere_lineique(int num,bool force)
// { // dimensionnement des tableaux d'indicateurs
// PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// ElemGeomC0 & el = *(CoPenta->pentaed);
// int tail_ar = el.NonS().Taille(); // nombre d'arête
// unefois->CalSMRlin.Change_taille(11);
// unefois->CalSMRlin_t.Change_taille(tail_ar);
// unefois->CalSMRlin_tdt.Change_taille(tail_ar);
// // appel de la fonction d'ElemMeca
// return ElemMeca::Frontiere_lineique(num,force);
//
//
// // le calcul et la création ne sont effectués qu'au premier appel
// // ou lorsque l'on veut forcer une recréation
// if ((ind_front_lin == 0) || force || (ind_front_lin == 2))
// {PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// ElemGeomC0 & el = *(CoPenta->pentaed);
// DdlElement & tdd = CoPenta->tab_ddl;
// int taille = tabb.Taille(); // la taille initiales des frontières
// int tail_s = el.Nonf().Taille(); // nombre de faces
// int tail_a = el.NonS().Taille(); // nombre d'arête
// posi_tab_front_lin = 0; // init indice de début d'arrête dans tabb
// // dimensionnement du tableau de frontières ligne si nécessaire
// if (ind_front_lin == 0)
// {if (ind_front_surf > 0)
// // cas où il y a déjà des surfaces et pas de lignes
// { tabb.Change_taille(tail_a + tail_s);
// posi_tab_front_lin = tail_s;
// // on s'occupe également des indicateurs
// unefois->CalSMsurf_t.Change_taille(tail_a + tail_s);
// unefois->CalSMsurf_tdt.Change_taille(tail_a + tail_s);
// unefois->CalSMRsurf.Change_taille(tail_a + tail_s);
// }
// else // cas pas de lignes et de surfaces
// { tabb.Change_taille(tail_a);
// // et c'est ok pour posi_tab_front_lin
// // on s'occupe également des indicateurs
// unefois->CalSMsurf_t.Change_taille(tail_a);
// unefois->CalSMsurf_tdt.Change_taille(tail_a);
// unefois->CalSMRsurf.Change_taille(tail_a);
// }
// }
// // création éventuelle des lignes
// for (int nlign=1;nlign<=tail_a;nlign++)
// if (tabb(posi_tab_front_lin+nlign) == NULL)
// { int nbnoe = el.NonS()(nlign).Taille(); // nb noeud de l'arête
// Tableau <Noeud *> tab(nbnoe); // les noeuds de l'arête frontiere
// DdlElement ddelem(nbnoe); // les ddlelements des noeuds frontieres
// for (int i=1;i<= nbnoe;i++)
// { tab(i) = tab_noeud(el.NonS()(nlign)(i));
// ddelem.Change_un_ddlNoeudElement(i,tdd(el.NonS()(nlign)(i)));
// // ddelem(i) = tdd(el.NonS()(nlign)(i));
// }
// if ((nlign == 4) || (nlign == 5) || (nlign == 6) )
// // cas des lignes verticales
// {tabb(posi_tab_front_lin+nlign) = new_frontiere_lin_rec(tab,ddelem);}
// else
// // cas des lignes horizontales
// {tabb(posi_tab_front_lin+nlign) = new_frontiere_lin_tri(tab,ddelem);}
// }
// // mise à jour de l'indicateur
// ind_front_lin = 1;
// }
//
// return (ElFrontiere*)tabb(num + posi_tab_front_lin);
// };
//
// ramène la frontière surfacique
// éventuellement création d'une frontieres surfacique de l'element et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour de l'elements
@ -1614,35 +1435,13 @@ ElFrontiere* const PentaMemb::Frontiere_surfacique(int num,bool force)
// on s'occupe également des indicateurs
unefois->CalSMsurf_t.Change_taille(tail_fa);unefois->CalSMsurf_tdt.Change_taille(tail_fa);
unefois->CalSMRsurf.Change_taille(tail_fa);
};
};
// normalement la frontière est créé on la ramène
return (ElFrontiere*)tabb(num);
};
// { // dimensionnement des tableaux d'indicateurs
// PentaMemb::DonnComPenta* CoPenta = unefois->doCoMemb; // pour simplifier l'écriture
// ElemGeomC0 & el = *(CoPenta->pentaed);
// int tail_ar = el.NonS().Taille(); // nombre d'arête
// unefois->CalSMRsurf.Change_taille(tail_ar);
// unefois->CalSMRsurf.Change_taille(tail_ar);
// unefois->CalSMRsurf.Change_taille(tail_ar);
// // appel de la fonction d'ElemMeca
// return ElemMeca::Frontiere_surfacique(num,force);
//
//// // le calcul et la création ne sont effectués qu'au premier appel
//// // ou lorsque l'on veut forcer une recréation
//// // on regarde si les frontières surfaciques existent sinon on les crée
//// if (ind_front_surf == 1)
//// return (ElFrontiere*)tabb(num);
//// else if ( ind_front_surf == 2)
//// // cas où certaines frontières existent
//// {if (tabb(num) != NULL)
//// return (ElFrontiere*)tabb(num);}
//// // dans tous les autres cas on reconstruit les frontières
//// Frontiere(force);
//// return (ElFrontiere*)tabb(num);
// };
// -------------------- calcul de frontières en protected -------------------
@ -1650,25 +1449,25 @@ ElFrontiere* const PentaMemb::Frontiere_surfacique(int num,bool force)
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
ElFrontiere* PentaMemb::new_frontiere_lin(int nlign,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ElFrontiere* fro_retour=NULL;
if ((nlign == 4) || (nlign == 5) || (nlign == 6) )
// cas des lignes verticales
{fro_retour = new_frontiere_lin_rec(tab,ddelem);}
else
// cas des lignes horizontales
{fro_retour = new_frontiere_lin_tri(tab,ddelem);}
return fro_retour;
};
{ElFrontiere* fro_retour=NULL;
if ((nlign == 4) || (nlign == 5) || (nlign == 6) )
// cas des lignes verticales
{fro_retour = new_frontiere_lin_rec(tab,ddelem);}
else
// cas des lignes horizontales
{fro_retour = new_frontiere_lin_tri(tab,ddelem);}
return fro_retour;
};
ElFrontiere* PentaMemb::new_frontiere_surf(int nface,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ElFrontiere* fro_retour=NULL;
if ((nface == 1) || (nface == 4))
// les faces 1 et 4 sont triangulaire
{fro_retour = new_frontiere_surf_tri(tab,ddelem);}
else
// les faces 2,3 et 5 sont quadrangulaire
{fro_retour = new_frontiere_surf_rec(tab,ddelem); }
return fro_retour;
};
{ElFrontiere* fro_retour=NULL;
if ((nface == 1) || (nface == 4))
// les faces 1 et 4 sont triangulaire
{fro_retour = new_frontiere_surf_tri(tab,ddelem);}
else
// les faces 2,3 et 5 sont quadrangulaire
{fro_retour = new_frontiere_surf_rec(tab,ddelem); }
return fro_retour;
};
// liberation de la place pointee
void PentaMemb::Libere ()
@ -1697,7 +1496,7 @@ void PentaMemb::DefLoi (LoiAbstraiteGeneral * NouvelleLoi)
loiComp->Def_type_deformation(*def);
// on active les données particulières nécessaires au fonctionnement de la loi de comp
loiComp->Activation_donnees(tab_noeud,dilatation,lesPtMecaInt);
};
};
// cas d'une loi thermo physique
if (GroupeThermique(NouvelleLoi->Id_categorie()))
{loiTP = (CompThermoPhysiqueAbstraite *) NouvelleLoi;
@ -1706,7 +1505,7 @@ void PentaMemb::DefLoi (LoiAbstraiteGeneral * NouvelleLoi)
for (int i=1;i<= imax;i++) tabSaveTP(i) = loiTP->New_et_Initialise();
// on active les données particulières nécessaires au fonctionnement de la loi de comp
loiTP->Activation_donnees(tab_noeud);
};
};
// cas d'une loi de frottement
if (GroupeFrottement(NouvelleLoi->Id_categorie()))
loiFrot = (CompFrotAbstraite *) NouvelleLoi;
@ -1739,9 +1538,9 @@ int PentaMemb::TestComplet()
// sa creation avec les donnees du bloc transmis
// ici la masse volumique
Element* PentaMemb::Complete(BlocGen & bloc,LesFonctions_nD* lesFonctionsnD)
{ // complétion avec bloc
return ElemMeca::Complete_ElemMeca(bloc,lesFonctionsnD);
};
{ // complétion avec bloc
return ElemMeca::Complete_ElemMeca(bloc,lesFonctionsnD);
};
// Compléter pour la mise en place de la gestion de l'hourglass
Element* PentaMemb::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const BlocGen & bloc)
@ -1762,7 +1561,7 @@ Element* PentaMemb::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const
// ajout du tableau de ddl des noeuds
void PentaMemb::ConstTabDdl()
{
{
Tableau <Ddl> ta(ParaGlob::Dimension());
int posi = Id_nom_ddl("X1") -1;
int dim = ParaGlob::Dimension();
@ -1773,7 +1572,7 @@ Element* PentaMemb::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const
// attribution des ddls aux noeuds
for (int ne=1; ne<= nombre->nbne; ne++)
tab_noeud(ne)->PlusTabDdl(ta);
};
};
//------- calcul d'erreur, remontée des contraintes -------------------
@ -1825,7 +1624,7 @@ PentaMemb::DonnComPenta* PentaMemb::Init
lesPtMecaInt(ni).Change_Nb_pti(ni);
};
int nbddl = CoPenta->tab_ddl.NbDdl();
// int nbddl = CoPenta->tab_ddl.NbDdl();
// stockage des donnees particulieres de la loi de comportement mécanique au point d'integ
tabSaveDon.Change_taille(nombre->nbI);
// stockage des donnees particulieres de la loi de comportement thermo physique au point d'integ
@ -1984,7 +1783,7 @@ void PentaMemb::Destruction()
delete CoPenta->residus_externeS(i);
for (int i=1;i<= 2;i++)
delete CoPenta->raideurs_externeS(i);
if (CoPenta->pentaedHourg != NULL) delete CoPenta->pentaedHourg;
if (CoPenta->pentaedHourg != NULL) delete CoPenta->pentaedHourg;
}
};

View file

@ -107,14 +107,14 @@ class PentaMemb : public ElemMeca
// Constructeur par defaut
PentaMemb ();
// Constructeur fonction d'un numero
// d'identification , d'identificateur d'interpolation et de geometrie et éventuellement un string d'information annexe
PentaMemb (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt,string info="");
// Constructeur fonction d'un numero
// d'identification , d'identificateur d'interpolation et de geometrie et éventuellement un string d'information annexe
PentaMemb (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt,string info="");
// Constructeur fonction d'un numero de maillage et d'identification,
// du tableau de connexite des noeuds, d'identificateur d'interpolation et de geometrie
// et éventuellement un string d'information annexe
PentaMemb (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt,
// Constructeur fonction d'un numero de maillage et d'identification,
// du tableau de connexite des noeuds, d'identificateur d'interpolation et de geometrie
// et éventuellement un string d'information annexe
PentaMemb (int num_mail,int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt,
const Tableau<Noeud *>& tab,string info="") ;
// Constructeur de copie
@ -134,9 +134,9 @@ class PentaMemb : public ElemMeca
// Lecture des donnees de la classe sur fichier
void LectureDonneesParticulieres (UtilLecture *,Tableau<Noeud *> * );
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
void Info_com_Element(UtilLecture * entreePrinc,string& ordre,Tableau<Noeud *> * tabMaillageNoeud)
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
void Info_com_Element(UtilLecture * entreePrinc,string& ordre,Tableau<Noeud *> * tabMaillageNoeud)
{ return Element::Info_com_El(nombre->nbne,entreePrinc,ordre,tabMaillageNoeud);};
// ramene l'element geometrique
@ -180,15 +180,16 @@ class PentaMemb : public ElemMeca
}
};
// retour des contraintes en absolu retour true si elle existe sinon false
bool ContraintesAbsolues(Tableau <Vecteur>& tabSig)
{ if (unefois->CalResPrem_t == 1)
ElemMeca::ContraintesEnAbsolues(false,lesPtMecaInt.TabSigHH_t(),tabSig);
else
{ ElemMeca::ContraintesEnAbsolues(true,lesPtMecaInt.TabSigHH_t(),tabSig);
unefois->CalResPrem_t = 1;
}
return true; }
// retour des contraintes en absolu retour true si elle existe sinon false
bool ContraintesAbsolues(Tableau <Vecteur>& tabSig)
{ if (unefois->CalResPrem_t == 1)
ElemMeca::ContraintesEnAbsolues(false,lesPtMecaInt.TabSigHH_t(),tabSig);
else
{ ElemMeca::ContraintesEnAbsolues(true,lesPtMecaInt.TabSigHH_t(),tabSig);
unefois->CalResPrem_t = 1;
}
return true;
}
// Libere la place occupee par le residu et eventuellement la raideur
// par l'appel de Libere de la classe mere et libere les differents tenseurs
@ -199,8 +200,8 @@ class PentaMemb : public ElemMeca
// acquisition d'une loi de comportement
void DefLoi (LoiAbstraiteGeneral * NouvelleLoi);
// test si l'element est complet
// = 1 tout est ok, =0 element incomplet
// test si l'element est complet
// = 1 tout est ok, =0 element incomplet
int TestComplet();
// procesure permettant de completer l'element apres
@ -238,20 +239,20 @@ class PentaMemb : public ElemMeca
Vecteur* CalculResidu_tdt (const ParaAlgoControle & pa)
{ return PentaMemb::CalculResidu(true,pa);};
// Calcul de la matrice masse pour l'élément
Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) ;
// Calcul de la matrice masse pour l'élément
Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) ;
// --------- calcul dynamique ---------
// calcul de la longueur d'arrête de l'élément minimal
// divisé par la célérité la plus rapide dans le matériau
double Long_arrete_mini_sur_c(Enum_dure temps)
{ return ElemMeca::Interne_Long_arrete_mini_sur_c(temps);};
// --------- calcul dynamique ---------
// calcul de la longueur d'arrête de l'élément minimal
// divisé par la célérité la plus rapide dans le matériau
double Long_arrete_mini_sur_c(Enum_dure temps)
{ return ElemMeca::Interne_Long_arrete_mini_sur_c(temps);};
//------- calcul d'erreur, remontée des contraintes -------------------
// 1) calcul du résidu et de la matrice de raideur pour le calcul d'erreur
Element::Er_ResRaid ContrainteAuNoeud_ResRaid();
// 2) remontée aux erreurs aux noeuds
Element::Er_ResRaid ErreurAuNoeud_ResRaid();
//------- calcul d'erreur, remontée des contraintes -------------------
// 1) calcul du résidu et de la matrice de raideur pour le calcul d'erreur
Element::Er_ResRaid ContrainteAuNoeud_ResRaid();
// 2) remontée aux erreurs aux noeuds
Element::Er_ResRaid ErreurAuNoeud_ResRaid();
// ------- affichage ou récupération d'informations --------------
// retourne un numero d'ordre d'un point le plus près ou est exprimé la grandeur enum
@ -262,218 +263,200 @@ class PentaMemb : public ElemMeca
int PointLePlusPres(Enum_dure temps,Enum_ddl enu, const Coordonnee& M)
{ return PtLePlusPres(temps,enu,M);};
// recuperation des coordonnées du point de numéro d'ordre iteg pour
// la grandeur enu
// recuperation des coordonnées du point de numéro d'ordre iteg pour
// la grandeur enu
// temps: dit si c'est à 0 ou t ou tdt
// si erreur retourne erreur à true
Coordonnee CoordPtInteg(Enum_dure temps,Enum_ddl enu,int iteg,bool& erreur)
// si erreur retourne erreur à true
Coordonnee CoordPtInteg(Enum_dure temps,Enum_ddl enu,int iteg,bool& erreur)
{ return CoordPtInt(temps,enu,iteg,erreur);};
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
Tableau <double> Valeur_a_diff_temps(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu,int iteg);
// récupération des valeurs au numéro d'ordre = iteg pour les grandeurs enu
// ici il s'agit de grandeurs tensorielles, le retour s'effectue dans la liste
// de conteneurs quelconque associée
void ValTensorielle_a_diff_temps(bool absolue,Enum_dure enu_t,List_io<TypeQuelconque>& enu,int iteg);
// récupération des valeurs au numéro d'ordre = iteg pour
// les grandeur enu
Tableau <double> Valeur_a_diff_temps(bool absolue,Enum_dure enu_t,const List_io<Ddl_enum_etendu>& enu,int iteg);
// récupération des valeurs au numéro d'ordre = iteg pour les grandeurs enu
// ici il s'agit de grandeurs tensorielles, le retour s'effectue dans la liste
// de conteneurs quelconque associée
void ValTensorielle_a_diff_temps(bool absolue,Enum_dure enu_t,List_io<TypeQuelconque>& enu,int iteg);
//============= lecture écriture dans base info ==========
// cas donne le niveau de la récupération
// 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 Lecture_base_info
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ofstream& sort,const int cas) ;
// 2) derivant des virtuelles
// retourne un tableau de ddl element, correspondant à la
// composante de sigma -> SIG11, pour chaque noeud qui contiend
// des ddl de contrainte
// -> utilisé pour l'assemblage de la raideur d'erreur
DdlElement& Tableau_de_Sig1() const
// retourne un tableau de ddl element, correspondant à la
// composante de sigma -> SIG11, pour chaque noeud qui contiend
// des ddl de contrainte
// -> utilisé pour l'assemblage de la raideur d'erreur
DdlElement& Tableau_de_Sig1() const
{return unefois->doCoMemb->tab_Err1Sig11;} ;
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// actualisation des ddl et des grandeurs actives de t+dt vers t
void TdtversT();
// actualisation des ddl et des grandeurs actives de t vers tdt
void TversTdt();
// calcul de l'erreur sur l'élément. Ce calcul n'est disponible
// qu'une fois la remontée aux contraintes effectuées sinon aucune
// action. En retour la valeur de l'erreur sur l'élément
// type indique le type de calcul d'erreur :
void ErreurElement(int type,double& errElemRelative
,double& numerateur, double& denominateur);
// calcul de l'erreur sur l'élément. Ce calcul n'est disponible
// qu'une fois la remontée aux contraintes effectuées sinon aucune
// action. En retour la valeur de l'erreur sur l'élément
// type indique le type de calcul d'erreur :
void ErreurElement(int type,double& errElemRelative
,double& numerateur, double& denominateur);
// calcul des seconds membres suivant les chargements
// cas d'un chargement en pression volumique,
// force indique la force volumique appliquée
// retourne le second membre résultant
// ici on l'épaisseur de l'élément pour constituer le volume
// -> explicite à t
Vecteur SM_charge_volumique_E_t
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_)
{ return PentaMemb::SM_charge_volumique_E(force,pt_fonct,false,pa,sur_volume_finale_);} ;
// -> explicite à tdt
Vecteur SM_charge_volumique_E_tdt
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_)
{ return PentaMemb::SM_charge_volumique_E(force,pt_fonct,true,pa,sur_volume_finale_);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_volumique_I
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_) ;
// calcul des seconds membres suivant les chargements
// cas d'un chargement en pression volumique,
// force indique la force volumique appliquée
// retourne le second membre résultant
// ici on l'épaisseur de l'élément pour constituer le volume
// -> explicite à t
Vecteur SM_charge_volumique_E_t
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_)
{ return PentaMemb::SM_charge_volumique_E(force,pt_fonct,false,pa,sur_volume_finale_);} ;
// -> explicite à tdt
Vecteur SM_charge_volumique_E_tdt
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_)
{ return PentaMemb::SM_charge_volumique_E(force,pt_fonct,true,pa,sur_volume_finale_);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_volumique_I
(const Coordonnee& force,Fonction_nD* pt_fonct,const ParaAlgoControle & pa,bool sur_volume_finale_) ;
// cas d'un chargement surfacique, sur les frontières des éléments
// force indique la force surfacique appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// -> version explicite à t
Vecteur SM_charge_surfacique_E_t(const Coordonnee& force,Fonction_nD* pt_fonct
,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_surfacique_E(force,pt_fonct,numFace,false,pa);} ;
// -> version explicite à tdt
Vecteur SM_charge_surfacique_E_tdt(const Coordonnee& force,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_surfacique_E(force,pt_fonct,numFace,true,pa);} ;
// -> implicite,
// pa : permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_surfacique_I
(const Coordonnee& force,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa) ;
// cas d'un chargement surfacique, sur les frontières des éléments
// force indique la force surfacique appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// -> version explicite à t
Vecteur SM_charge_surfacique_E_t(const Coordonnee& force,Fonction_nD* pt_fonct
,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_surfacique_E(force,pt_fonct,numFace,false,pa);} ;
// -> version explicite à tdt
Vecteur SM_charge_surfacique_E_tdt(const Coordonnee& force,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_surfacique_E(force,pt_fonct,numFace,true,pa);} ;
// -> implicite,
// pa : permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_surfacique_I
(const Coordonnee& force,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa) ;
// cas d'un chargement de type pression unidirectionnelle, sur les frontières des éléments
// presUniDir indique le vecteur appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_presUniDir_E_t(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_presUniDir_E(presUniDir,pt_fonct,numFace,false,pa);} ;
// -> explicite à tdt
Vecteur SM_charge_presUniDir_E_tdt(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_presUniDir_E(presUniDir,pt_fonct,numFace,true,pa);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_presUniDir_I(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa);
// cas d'un chargement de type pression unidirectionnelle, sur les frontières des éléments
// presUniDir indique le vecteur appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_presUniDir_E_t(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_presUniDir_E(presUniDir,pt_fonct,numFace,false,pa);} ;
// -> explicite à tdt
Vecteur SM_charge_presUniDir_E_tdt(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_presUniDir_E(presUniDir,pt_fonct,numFace,true,pa);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_presUniDir_I(const Coordonnee& presUniDir,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa);
// cas d'un chargement lineique, sur les aretes frontières des éléments
// force indique la force lineique appliquée
// numarete indique le numéro de l'arete chargée
// retourne le second membre résultant
// NB: il y a une définition par défaut pour les éléments qui n'ont pas
// d'arete externe -> message d'erreur d'où le virtuel et non virtuel pur
// -> explicite à t
Vecteur SM_charge_lineique_E_t(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_lineique_E(force,pt_fonct,numArete,false,pa);} ;
// -> explicite à tdt
Vecteur SM_charge_lineique_E_tdt(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_lineique_E(force,pt_fonct,numArete,true,pa);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_lineique_I(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa) ;
// cas d'un chargement lineique, sur les aretes frontières des éléments
// force indique la force lineique appliquée
// numarete indique le numéro de l'arete chargée
// retourne le second membre résultant
// NB: il y a une définition par défaut pour les éléments qui n'ont pas
// d'arete externe -> message d'erreur d'où le virtuel et non virtuel pur
// -> explicite à t
Vecteur SM_charge_lineique_E_t(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_lineique_E(force,pt_fonct,numArete,false,pa);} ;
// -> explicite à tdt
Vecteur SM_charge_lineique_E_tdt(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_lineique_E(force,pt_fonct,numArete,true,pa);} ;
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_lineique_I(const Coordonnee& force,Fonction_nD* pt_fonct,int numArete,const ParaAlgoControle & pa) ;
// cas d'un chargement de type pression, sur les frontières des éléments
// pression indique la pression appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// NB: il y a une définition par défaut pour les éléments qui n'ont pas de
// surface externe -> message d'erreur d'où le virtuel et non virtuel pur
// -> explicite à t
Vecteur SM_charge_pression_E_t(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_pression_E(pression,pt_fonct,numFace,false,pa);};
// -> explicite à tdt
Vecteur SM_charge_pression_E_tdt(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_pression_E(pression,pt_fonct,numFace,true,pa);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_pression_I(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa) ;
// cas d'un chargement de type pression, sur les frontières des éléments
// pression indique la pression appliquée
// numface indique le numéro de la face chargée
// retourne le second membre résultant
// NB: il y a une définition par défaut pour les éléments qui n'ont pas de
// surface externe -> message d'erreur d'où le virtuel et non virtuel pur
// -> explicite à t
Vecteur SM_charge_pression_E_t(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_pression_E(pression,pt_fonct,numFace,false,pa);};
// -> explicite à tdt
Vecteur SM_charge_pression_E_tdt(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa)
{ return PentaMemb::SM_charge_pression_E(pression,pt_fonct,numFace,true,pa);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_pression_I(double pression,Fonction_nD* pt_fonct,int numFace,const ParaAlgoControle & pa) ;
// cas d'un chargement surfacique hydrostatique,
// poidvol: indique le poids volumique du liquide
// M_liquide : un point de la surface libre
// dir_normal_liquide : direction normale à la surface libre
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_hydrostatique_E_t(const Coordonnee& dir_normal_liquide,const double& poidvol
// cas d'un chargement surfacique hydrostatique,
// poidvol: indique le poids volumique du liquide
// M_liquide : un point de la surface libre
// dir_normal_liquide : direction normale à la surface libre
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_hydrostatique_E_t(const Coordonnee& dir_normal_liquide,const double& poidvol
,int numFace,const Coordonnee& M_liquide
,const ParaAlgoControle & pa
,bool sans_limitation)
{ return PentaMemb::SM_charge_hydrostatique_E(dir_normal_liquide,poidvol,numFace,M_liquide,false,pa,sans_limitation);};
// -> explicite à tdt
Vecteur SM_charge_hydrostatique_E_tdt(const Coordonnee& dir_normal_liquide,const double& poidvol
,int numFace,const Coordonnee& M_liquide
,const ParaAlgoControle & pa
,bool sans_limitation)
{ return PentaMemb::SM_charge_hydrostatique_E(dir_normal_liquide,poidvol,numFace,M_liquide,false,pa,sans_limitation);};
// -> explicite à tdt
Vecteur SM_charge_hydrostatique_E_tdt(const Coordonnee& dir_normal_liquide,const double& poidvol
,int numFace,const Coordonnee& M_liquide
,const ParaAlgoControle & pa
,bool sans_limitation)
{ return PentaMemb::SM_charge_hydrostatique_E(dir_normal_liquide,poidvol,numFace,M_liquide,true,pa,sans_limitation);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_hydrostatique_I(const Coordonnee& dir_normal_liquide,const double& poidvol
{ return PentaMemb::SM_charge_hydrostatique_E(dir_normal_liquide,poidvol,numFace,M_liquide,true,pa,sans_limitation);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_hydrostatique_I(const Coordonnee& dir_normal_liquide,const double& poidvol
,int numFace,const Coordonnee& M_liquide
,const ParaAlgoControle & pa
,bool sans_limitation) ;
// cas d'un chargement surfacique hydro-dynamique,
// Il y a trois forces: une suivant la direction de la vitesse: de type traînée aerodynamique
// Fn = poids_volu * fn(V) * S * (normale*u) * u, u étant le vecteur directeur de V (donc unitaire)
// une suivant la direction normale à la vitesse de type portance
// Ft = poids_volu * ft(V) * S * (normale*u) * w, w unitaire, normal à V, et dans le plan n et V
// une suivant la vitesse tangente de type frottement visqueux
// T = to(Vt) * S * ut, Vt étant la vitesse tangentielle et ut étant le vecteur directeur de Vt
// coef_mul: est un coefficient multiplicateur global (de tout)
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_hydrodynamique_E_t( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numFace,const double& coef_mul
, Courbe1D* coef_aero_t
,const ParaAlgoControle & pa)
{return SM_charge_hydrodynamique_E(frot_fluid,poidvol,coef_aero_n,numFace,coef_mul,coef_aero_t,false,pa);};
// -> explicite à tdt
Vecteur SM_charge_hydrodynamique_E_tdt( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numFace,const double& coef_mul
, Courbe1D* coef_aero_t,const ParaAlgoControle & pa)
{return SM_charge_hydrodynamique_E(frot_fluid,poidvol,coef_aero_n,numFace,coef_mul,coef_aero_t,true,pa);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_hydrodynamique_I( Courbe1D* frot_fluid,const double& poidvol
// cas d'un chargement surfacique hydro-dynamique,
// Il y a trois forces: une suivant la direction de la vitesse: de type traînée aerodynamique
// Fn = poids_volu * fn(V) * S * (normale*u) * u, u étant le vecteur directeur de V (donc unitaire)
// une suivant la direction normale à la vitesse de type portance
// Ft = poids_volu * ft(V) * S * (normale*u) * w, w unitaire, normal à V, et dans le plan n et V
// une suivant la vitesse tangente de type frottement visqueux
// T = to(Vt) * S * ut, Vt étant la vitesse tangentielle et ut étant le vecteur directeur de Vt
// coef_mul: est un coefficient multiplicateur global (de tout)
// retourne le second membre résultant
// -> explicite à t
Vecteur SM_charge_hydrodynamique_E_t( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numFace,const double& coef_mul
, Courbe1D* coef_aero_t
,const ParaAlgoControle & pa)
{return SM_charge_hydrodynamique_E(frot_fluid,poidvol,coef_aero_n,numFace,coef_mul,coef_aero_t,false,pa);};
// -> explicite à tdt
Vecteur SM_charge_hydrodynamique_E_tdt( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numFace,const double& coef_mul
, Courbe1D* coef_aero_t,const ParaAlgoControle & pa) ;
, Courbe1D* coef_aero_t,const ParaAlgoControle & pa)
{return SM_charge_hydrodynamique_E(frot_fluid,poidvol,coef_aero_n,numFace,coef_mul,coef_aero_t,true,pa);};
// -> implicite,
// pa: permet de déterminer si oui ou non on calcul la contribution à la raideur
// retourne le second membre et la matrice de raideur correspondant
ResRaid SMR_charge_hydrodynamique_I( Courbe1D* frot_fluid,const double& poidvol
, Courbe1D* coef_aero_n,int numFace,const double& coef_mul
, Courbe1D* coef_aero_t,const ParaAlgoControle & pa) ;
// ========= définition et/ou construction des frontières ===============
// ========= définition et/ou construction des frontières ===============
// Calcul des frontieres de l'element
// creation des elements frontieres et retour du tableau de ces elements
// la création n'a lieu qu'au premier appel
// ou lorsque l'on force le paramètre force a true
// dans ce dernier cas seul les frontière effacées sont recréée
Tableau <ElFrontiere*> const & Frontiere(bool force = false);
// ramène la frontière point
// éventuellement création des frontieres points de l'element et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour de l'elements
// a moins que le paramètre force est mis a true
// dans ce dernier cas la frontière effacéee est recréée
// num indique le numéro du point à créer (numérotation EF)
// ElFrontiere* const Frontiere_points(int num,bool force = false);
// ramène la frontière linéique
// éventuellement création des frontieres linéique de l'element et stockage dans l'element
// si c'est la première fois et en 3D sinon il y a seulement retour de l'elements
// a moins que le paramètre force est mis a true
// dans ce dernier cas la frontière effacéee est recréée
// num indique le numéro de l'arête à créer (numérotation EF)
// on maintient la fonction ici, car elle fait des choses qui ne sont pas fait
// dans la fonction d'ElemMeca
// ElFrontiere* const Frontiere_lineique(int num,bool force = false);
// ramène la frontière surfacique
// éventuellement création des frontieres surfacique de l'element et stockage dans l'element
// si c'est la première fois sinon il y a seulement retour de l'elements
@ -484,22 +467,22 @@ class PentaMemb : public ElemMeca
// -------------------- calcul de frontières en protected -------------------
// --- fonction nécessaire pour la construction des Frontières linéiques ou surfaciques particulière à l'élément
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
virtual ElFrontiere* new_frontiere_lin(int num,Tableau <Noeud *> & tab, DdlElement& ddelem);
virtual ElFrontiere* new_frontiere_surf(int num,Tableau <Noeud *> & tab, DdlElement& ddelem);
// --- fonction nécessaire pour la construction des Frontières linéiques ou surfaciques particulière à l'élément
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
virtual ElFrontiere* new_frontiere_lin(int num,Tableau <Noeud *> & tab, DdlElement& ddelem);
virtual ElFrontiere* new_frontiere_surf(int num,Tableau <Noeud *> & tab, DdlElement& ddelem);
// 3) methodes propres a l'element
// ajout du tableau specific de ddl des noeuds
// la procedure met a jour les ddl(relatif a l'element, c-a-d Xi)
// des noeuds constituants l'element
void ConstTabDdl();
// ajout du tableau specific de ddl des noeuds
// la procedure met a jour les ddl(relatif a l'element, c-a-d Xi)
// des noeuds constituants l'element
void ConstTabDdl();
public :
// -------------- definition de la classe conteneur de donnees communes ------------
class DonnComPenta
public :
// -------------- definition de la classe conteneur de donnees communes ------------
class DonnComPenta
{ public :
// penta1 doit pointer sur un element deja existant via un new
DonnComPenta (ElemGeomC0* penta1,DdlElement& tab,DdlElement& tabErr,DdlElement& tab_Err1Sig,
@ -559,10 +542,10 @@ class PentaMemb : public ElemMeca
Mat_pleine matrice_masse;
ElemGeomC0* pentaedMas; // contiend les fonctions d'interpolation et ...
// pour les calculs relatifs à la masse
// ------ blocage éventuel d'hourglass
// utiliser dans ElemMeca::Cal_mat_hourglass_comp, Cal_implicit_hourglass, Cal_explici_hourglass
// ------ blocage éventuel d'hourglass
// utiliser dans ElemMeca::Cal_mat_hourglass_comp, Cal_implicit_hourglass, Cal_explici_hourglass
ElemGeomC0* pentaedHourg; // contiend les fonctions d'interpolation
};
};
// classe contenant tous les indicateurs statique qui sont modifiés une seule fois
// et un pointeur sur les données statiques communes
@ -573,8 +556,8 @@ class PentaMemb : public ElemMeca
UneFois () ; // constructeur par défaut
~UneFois () ; // destructeur
// VARIABLES :
public :
// VARIABLES :
public :
PentaMemb::DonnComPenta * doCoMemb;
// incicateurs permettant de dimensionner seulement au premier passage
@ -593,7 +576,7 @@ class PentaMemb : public ElemMeca
int CalSMvol; // pour les seconds membres concernant les volumes
int CalDynamique; // pour le calcul de la matrice de masse
int CalPt_0_t_tdt; // pour le calcul de point à 0 t et tdt
// ---------- sauvegarde du nombre d'élément en cours --------
// ---------- sauvegarde du nombre d'élément en cours --------
int nbelem_in_Prog;
};
@ -601,19 +584,19 @@ class PentaMemb : public ElemMeca
protected :
// VARIABLES PRIVEES :
UneFois * unefois; // pointeur défini dans la classe dérivée
// VARIABLES PRIVEES :
UneFois * unefois; // pointeur défini dans la classe dérivée
// grandeurs aux points d'intégration: contraintes, déformations, vitesses de def etc.
LesPtIntegMecaInterne lesPtMecaInt;
// grandeurs aux points d'intégration: contraintes, déformations, vitesses de def etc.
LesPtIntegMecaInterne lesPtMecaInt;
// type structuré et pointeur pour construire les éléments
// le pointeur est défini dans le type dérivé
class NombresConstruire
// type structuré et pointeur pour construire les éléments
// le pointeur est défini dans le type dérivé
class NombresConstruire
{ public:
NombresConstruire():nbne(0),nbneSQ(0),nbneST(0),nbneAQ(0),nbneAT(0),nbI(0)
,nbiQ(0),nbiT(0),nbiEr(0),nbiV(0),nbiSQ(0),nbiST(0),nbiAQ(0)
,nbiAT(0),nbiMas(0),nbiHour(0) {};
NombresConstruire():nbne(0),nbneSQ(0),nbneST(0),nbneAQ(0),nbneAT(0),nbI(0)
,nbiQ(0),nbiT(0),nbiEr(0),nbiV(0),nbiSQ(0),nbiST(0),nbiAQ(0)
,nbiAT(0),nbiMas(0),nbiHour(0) {};
int nbne; // le nombre de noeud de l'élément
int nbneSQ ; // le nombre de noeud des facettes quadrangulaires
int nbneST ; // le nombre de noeud des facettes triangulaires
@ -630,34 +613,34 @@ class PentaMemb : public ElemMeca
int nbiAT; // nB pt integ pour calcul second membre linéique des arête des triangles
int nbiMas; // le nombre de point d'intégration pour le calcul de la matrice masse
int nbiHour; // éventuellement, le nombre de point d'intégration un blocage d'hourglass
};
NombresConstruire * nombre; // le pointeur défini dans la classe dérivée d'hexamemb
};
NombresConstruire * nombre; // le pointeur défini dans la classe dérivée d'hexamemb
// =====>>>> methodes appelees par les classes dérivees <<<<=====
// fonction d'initialisation servant dans les classes derivant
// au niveau du constructeur
// les pointeurs d'éléments géométriques sont non nul uniquement lorsque doCoMemb est null
// c'est-à-dire pour l'initialisation
PentaMemb::DonnComPenta* Init (ElemGeomC0* penta,ElemGeomC0* pentaEr,ElemGeomC0* pentaMas
,ElemGeomC0* pentaeHourg,bool sans_init_noeud = false);
// destructions de certaines grandeurs pointées, créées au niveau de l'initialisation
void Destruction();
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
// frontière linéique verticale (rectangle)
virtual ElFrontiere* new_frontiere_lin_rec(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière linéique horizontale (triangle)
virtual ElFrontiere* new_frontiere_lin_tri(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière surfacique verticale (rectangle)
virtual ElFrontiere* new_frontiere_surf_rec(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière surfacique horizontale (triangle)
virtual ElFrontiere* new_frontiere_surf_tri(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// fonction d'initialisation servant dans les classes derivant
// au niveau du constructeur
// les pointeurs d'éléments géométriques sont non nul uniquement lorsque doCoMemb est null
// c'est-à-dire pour l'initialisation
PentaMemb::DonnComPenta* Init (ElemGeomC0* penta,ElemGeomC0* pentaEr,ElemGeomC0* pentaMas
,ElemGeomC0* pentaeHourg,bool sans_init_noeud = false);
// destructions de certaines grandeurs pointées, créées au niveau de l'initialisation
void Destruction();
// adressage des frontières linéiques et surfacique
// définit dans les classes dérivées, et utilisées pour la construction des frontières
// frontière linéique verticale (rectangle)
virtual ElFrontiere* new_frontiere_lin_rec(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière linéique horizontale (triangle)
virtual ElFrontiere* new_frontiere_lin_tri(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière surfacique verticale (rectangle)
virtual ElFrontiere* new_frontiere_surf_rec(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// frontière surfacique horizontale (triangle)
virtual ElFrontiere* new_frontiere_surf_tri(Tableau <Noeud *> & tab, DdlElement& ddelem) = 0;
// ==== >>>> methodes virtuelles dérivant d'ElemMeca ============
// ramene la dimension des tenseurs contraintes et déformations de l'élément
int Dim_sig_eps() const {return 3;};
// ramene la dimension des tenseurs contraintes et déformations de l'élément
int Dim_sig_eps() const {return 3;};
//------------ fonctions uniquement a usage interne ----------
private :
@ -667,7 +650,7 @@ class PentaMemb : public ElemMeca
PentaMemb::DonnComPenta* Def_DonneeCommune(ElemGeomC0* penta,ElemGeomC0* pentaEr
,ElemGeomC0* pentaMas,ElemGeomC0* pentaeHourg);
// Calcul du residu local a t ou tdt en fonction du booleen
Vecteur* CalculResidu (bool atdt,const ParaAlgoControle & pa);
Vecteur* CalculResidu (bool atdt,const ParaAlgoControle & pa);
// cas d'un chargement de type pression, sur les frontières des éléments
// pression indique la pression appliquée
// numface indique le numéro de la face chargée

View file

@ -37,9 +37,9 @@
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
// Constructeur

View file

@ -36,9 +36,9 @@
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
// --------- calcul dynamique ---------
// ajout des ddl de vitesse pour tous les maillages

View file

@ -39,9 +39,9 @@ using namespace std; //introduces namespace std
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
#include "ConstMath.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"

View file

@ -39,9 +39,9 @@ using namespace std; //introduces namespace std
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
#include "ConstMath.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"

View file

@ -39,9 +39,9 @@ using namespace std; //introduces namespace std
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
#include "ConstMath.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"

View file

@ -39,9 +39,9 @@ using namespace std; //introduces namespace std
#include <vector>
#include "List_io.h"
#include "CharUtil.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
#include "ConstMath.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"

View file

@ -140,7 +140,7 @@ class Visualisation_maple
void Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc);
// écriture des paramètres de l'ordre dans un flux
void Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc);
// demande si la visualisation vrml est validé ou pas
// demande si la visualisation maple est validée ou pas
bool Visu_maple_valide() {return activ_sort_maple;};
// inactive la visualisation maple
void Inactiv_Visu_maple() {activ_sort_maple=false;};

View file

@ -52,7 +52,7 @@
#include <stdlib.h>
#include <list>
#include <iomanip>
#include "LaList.h"
#include "LaLIST.h"
#include "Sortie.h"
#include "ParaGlob.h"
using namespace std; //introduces namespace std

View file

@ -211,11 +211,11 @@ Fonction_nD::Fonction_nD(const Fonction_nD& Co) :
// soit identique à celle du tableau Nom_variables() : en fait t_enu et tqi doivent représenter les variables
Tableau <double> & Fonction_nD::Valeur_FnD(Tableau <Ddl_etendu> * t_enu,Tableau <const TypeQuelconque * > * t_qi
,Tableau <int> * t_num_ordre)
{// on se sert des tableaux d'adressage indirect pour remplir le tableau de passage
// tab_enu_etendu(i) correspond à nom_variables(index_enu_etendu(i))
{ // on se sert des tableaux d'adressage indirect pour remplir le tableau de passage
// tab_enu_etendu(i) correspond à nom_variables(index_enu_etendu(i))
// tab_enu_quelconque(i) correspond à nom_variables(index_enu_quelconque(i))
// un tableau intermédiaire qui sert pour Valeur(Tableau <Ddl_etendu> ...
// Tableau <double > x_x_i;
// Tableau <double > x_x_i;
#ifdef MISE_AU_POINT
// on vérifie qu'il y a bien équivalence entre les variables
if (!equivalence_nom_enu_etendu_et_enu_quelconque)

View file

@ -28,8 +28,8 @@
#include "MathUtil2.h"
#include "nrutil.h"
#include "jacobi.h"
//#include "nrutil.h"
//#include "jacobi.h"
#include "Util.h"
#include "ConstMath.h"
#include "MathUtil.h"

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Hyper3D.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Hyper3DN.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "IsoHyper3DFavier3.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "IsoHyper3DOrgeas1.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "IsoHyper3DOrgeas2.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "IsoHyperBulk3.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -29,7 +29,7 @@
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "IsoHyperBulk_gene.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -30,7 +30,7 @@
#include "TreloarN.h"
#include "MathUtil.h"
#include "ComLoi_comp_abstraite.h"
//#include "ComLoi_comp_abstraite.h"
# include <iostream>
using namespace std; //introduces namespace std

View file

@ -70,7 +70,7 @@
#include "EnergieMeca.h"
#include "LesPtIntegMecaInterne.h"
#include "Temps_CPU_HZpp.h"
#include "bloc.h"
#include "Bloc.h"
class Loi_comp_abstraite : public LoiAbstraiteGeneral
{

View file

@ -1243,7 +1243,7 @@ void Loi_iso_elas3D::Calcul_DsigmaHH_tdt (TenseurHH& ,TenseurBB& ,DdlElement & t
// calcul des coefficients
double coef1 = (E*nu)/((1.-2.*nu)*(1+nu));
double coef2 = E/(1.+ nu);
// calcul du deviateur des deformations
// calcul de la trace des deformations
double Ieps = epsBH.Trace();
Tenseur3BH sigBH;
double untiers=1./3.;

View file

@ -62,7 +62,7 @@
#define LOICRITERE_H
#include "Loi_comp_abstraite.h"
#include "Enum_Critere_Loi.h"
#include "Enum_Critere_loi.h"
#include "LoiContraintesPlanes.h"
#include "LoiContraintesPlanesDouble.h"
#include "Coordonnee2.h"