rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Gérard Rio 2023-06-12 17:30:26 +02:00
parent a60ae7db18
commit a94858e424
34 changed files with 875 additions and 1242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Elements/Geometrie/ElemGeom/volume/GeomHexalin1.cc
View file

File diff suppressed because one or more lines are too long

1
Elements/Geometrie/ElemGeom/volume/GeomHexaqua.cc
View file

File diff suppressed because one or more lines are too long

1
Elements/Geometrie/ElemGeom/volume/GeomPentaedre.cc
View file

File diff suppressed because one or more lines are too long

1
Elements/Geometrie/ElemGeom/volume/GeomTetraedre.cc
View file

File diff suppressed because one or more lines are too long

124
Elements/Mecanique/Biellette/PoutSimple1.cc
View file

@ -115,7 +115,6 @@ void PoutSimple1::Def_DonnCommunPS1()
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));
// cas des ddl éléments secondaires pour le calcul d'erreur
// les tenseurs de contrainte sont de dimension 1 a priori
@ -123,7 +122,6 @@ void PoutSimple1::Def_DonnCommunPS1()
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
@ -391,8 +389,6 @@ PoutSimple1::PoutSimple1 (const PoutSimple1& pout) :
// tabSaveDon.Change_taille(1);
*(residu) = *(pout.residu);
*(raideur) = *(pout.raideur);
// met = (pout.met); // la métrique est commune
// *def = *(pout.def);
};
PoutSimple1::~PoutSimple1 ()
@ -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;
// };
//

24
Elements/Mecanique/Biellette/PoutSimple1.h
View file

@ -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& )

6
Elements/Mecanique/Deformation_gene/PiPoCo.h
View file

@ -127,7 +127,8 @@ 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
@ -137,7 +138,8 @@ 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::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

7
Elements/Mecanique/Pentaedre/PentaL.cc
View file

@ -135,7 +135,7 @@ PentaL::PentaL (int num_maill,int num_id) :
// 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)
@ -165,7 +165,8 @@ PentaL::PentaL (int num_maill,int num_id,const Tableau<Noeud *>& tab):
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); }
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
@ -176,7 +177,7 @@ PentaL::PentaL (int num_maill,int num_id,const Tableau<Noeud *>& tab):
// 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)

241
Elements/Mecanique/Pentaedre/PentaMemb.cc
View file

@ -583,8 +583,8 @@ void PentaMemb::ErreurElement(int type,double& errElemRelative
,double& numerateur, double& denominateur)
{ PentaMemb::DonnComPenta* doCoPenta = unefois->doCoMemb; // pour simplifier l'écriture
Tableau <TenseurBB *>& d_epsBB = unefois->doCoMemb->d_epsBB;
Tableau <TenseurHH *>& d_sigHH = unefois->doCoMemb->d_sigHH;
// Tableau <TenseurBB *>& d_epsBB = unefois->doCoMemb->d_epsBB;
// Tableau <TenseurHH *>& d_sigHH = unefois->doCoMemb->d_sigHH;
// dimensionnement de la metrique
if(!( unefois->CalResPrem_t ))
{ unefois->CalResPrem_t += 1;
@ -822,7 +822,8 @@ Vecteur PentaMemb::SM_charge_pression_E
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;
@ -832,7 +833,8 @@ Vecteur PentaMemb::SM_charge_pression_E
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))
@ -938,7 +940,8 @@ Vecteur PentaMemb::SM_charge_presUniDir_E
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;
@ -948,7 +951,8 @@ Vecteur PentaMemb::SM_charge_presUniDir_E
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))
@ -1177,7 +1181,8 @@ Vecteur PentaMemb::SM_charge_hydrostatique_E(const Coordonnee& dir_normal_liquid
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;
@ -1187,7 +1192,8 @@ Vecteur PentaMemb::SM_charge_hydrostatique_E(const Coordonnee& dir_normal_liquid
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))
@ -1306,7 +1312,8 @@ Vecteur PentaMemb::SM_charge_hydrodynamique_E( Courbe1D* frot_fluid,const doubl
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;
@ -1316,7 +1323,8 @@ Vecteur PentaMemb::SM_charge_hydrodynamique_E( Courbe1D* frot_fluid,const doubl
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)
@ -1403,197 +1411,10 @@ Tableau <ElFrontiere*> const & PentaMemb::Frontiere(bool force)
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
@ -1620,29 +1441,7 @@ ElFrontiere* const PentaMemb::Frontiere_surfacique(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->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 -------------------
@ -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

21
Elements/Mecanique/Pentaedre/PentaMemb.h
View file

@ -188,7 +188,8 @@ class PentaMemb : public ElemMeca
{ ElemMeca::ContraintesEnAbsolues(true,lesPtMecaInt.TabSigHH_t(),tabSig);
unefois->CalResPrem_t = 1;
}
return true; }
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
@ -456,24 +457,6 @@ class PentaMemb : public ElemMeca
// 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

6
Maillage/LesMaillages.cc
View file

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

6
Maillage/LesMaillages2.cc
View file

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

6
Maillage/Maillage.cc
View file

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

6
Maillage/Maillage2.cc
View file

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

6
Maillage/Maillage3.cc
View file

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

6
Maillage/maillage4.cc
View file

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

2
Resultats/MAPLE/Visualisation_maple.h
View file

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

2
TypeBase/List_io.h
View file

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

4
Util/MathUtil2.cc
View file

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

2
comportement/Hyper_elastique/Hyper3D.cc
View file

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

2
comportement/Hyper_elastique/Hyper3DN.cc
View file

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

2
comportement/Hyper_elastique/IsoHyper3DFavier3.cc
View file

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

2
comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc
View file

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

2
comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc
View file

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

2
comportement/Hyper_elastique/IsoHyperBulk3.cc
View file

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

2
comportement/Hyper_elastique/IsoHyperBulk_gene.cc
View file

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

2
comportement/Hyper_elastique/TreloarN.cc
View file

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

2
comportement/Loi_comp_abstraite.h
View file

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

2
comportement/iso_elas_hooke/Loi_iso_elas3D.cc
View file

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

2
comportement/lois_combinees/LoiCritere.h
View file

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