modifications d'édition, tabulation, orthographe ...
This commit is contained in:
parent
a60ae7db18
commit
a94858e424
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
@ -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
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
// };
|
||||
//
|
||||
|
||||
|
||||
|
|
|
@ -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 :
|
||||
|
|
|
@ -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
|
||||
|
||||
};
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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;};
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
{
|
||||
|
|
|
@ -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.;
|
||||
|
|
|
@ -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"
|
||||
|
|
Loading…
Reference in a new issue