Compare commits
No commits in common. "master" and "V_7.011" have entirely different histories.
1069 changed files with 28852 additions and 10393 deletions
BIN
.DS_Store
vendored
BIN
.DS_Store
vendored
Binary file not shown.
111
.gitignore
vendored
Executable file
111
.gitignore
vendored
Executable file
|
|
@ -0,0 +1,111 @@
|
|||
CVS/
|
||||
*copi*
|
||||
essai*
|
||||
*old*
|
||||
*.cp
|
||||
*essai
|
||||
*save*
|
||||
.DS_Store
|
||||
*.zip
|
||||
*.cpp
|
||||
*.f
|
||||
*copy*
|
||||
*maxima
|
||||
Readme
|
||||
*yaca
|
||||
*yaca*
|
||||
*.txt
|
||||
NRC/
|
||||
untitled
|
||||
*.texte
|
||||
*.sav
|
||||
FAQ
|
||||
ConsoleSIOUX.*
|
||||
ConsoleSIOUX.plc
|
||||
Carbon*
|
||||
*.xws
|
||||
tata
|
||||
*.sh
|
||||
*yacas
|
||||
*maxima*
|
||||
*yacas*
|
||||
*sauve*
|
||||
*.tex
|
||||
*.cpp*
|
||||
Algo/GalerkinContinu/AlgoMixte/AlgoriStatExpli.cc
|
||||
Algo/GalerkinContinu/AlgoMixte/AlgoriStatExpli.h
|
||||
Documentation/
|
||||
Elements/MecaFlu/
|
||||
Elements/Mecanique/SFE/Met_Sfe1s3_28sep.cc
|
||||
Elements/Mecanique/SFE/compaAnaHZ
|
||||
Elements/Mecanique/SFE/derive_courbure
|
||||
Elements/Remonte/
|
||||
Elements/Thermique/ElemPoint/
|
||||
Elements/Thermique/ElemThermiGene.h
|
||||
Elements/Thermique/Hexaedre/
|
||||
Elements/Thermique/Pentaedre/
|
||||
Elements/Thermique/Quad_asisymetrie/
|
||||
Elements/Thermique/SFE/
|
||||
Elements/Thermique/Tetraedre/
|
||||
Elements/Thermique/Tria_axisymetrie/
|
||||
Elements/Thermique/Triangle/
|
||||
Elements/Thermique/quadrangle/
|
||||
Flambage/Valpro.h
|
||||
G_Var_precompile/
|
||||
General/creatio_tube.c
|
||||
General/herezh.Projet
|
||||
General/suppres_tube.c
|
||||
Lecture/UtilXML.h
|
||||
Maillage/Renumerotation.cc
|
||||
Maillage/renume.cc
|
||||
Parametres/TypeCalcul.h
|
||||
Parametres/Type_Calcul.h
|
||||
Resolin/Resolution_Condi/Assemblage.cp_11-9-2001
|
||||
Resultats/Gid_25mars/
|
||||
Resultats/Gmsh_25mars/
|
||||
STL_bouquin/
|
||||
Tableaux/Tableau_T.cc
|
||||
TypeBase/Reels.h
|
||||
TypeBase/Reels3.cc
|
||||
TypeBase/Reels3.h
|
||||
TypeBase/TypePremierXML.h
|
||||
TypeBase/XPath.h
|
||||
TypeBase/XPath_hz.h
|
||||
TypeBase/XPointer.h
|
||||
TypeBase/XPointer_hz.h
|
||||
comportement/ComLoi_comp_abstraite.h
|
||||
comportement/ExceptionsLoiComp.h
|
||||
comportement/Hyper_elastique/Hyper1.cc
|
||||
comportement/Hyper_elastique/Hyper1.h
|
||||
comportement/Hyper_elastique/result
|
||||
comportement/Hyper_elastique/verif_Epartielles
|
||||
comportement/Hyper_elastique/verif_Etotal
|
||||
comportement/Hyper_elastique/verif_Si
|
||||
comportement/loi_visco_plastiques/
|
||||
comportement/lois_speciales/Loi_rien2D.cc
|
||||
comportement/lois_speciales/Loi_rien2D.h
|
||||
comportement/plasticite/Prandtl_Reuss.h_version1
|
||||
comportement/plasticite/Prandtl_Reuss1D.h.sept2001
|
||||
comportement/plasticite/Prandtl_Reuss_23_11_02.h
|
||||
macro/
|
||||
tenseurs_mai99/Coordonnees/Coordonnee3_T.cc
|
||||
tenseurs_mai99/Coordonnees/Coordonnee3_T.h
|
||||
tenseurs_mai99/Reperes_bases/Base_T.cc
|
||||
tenseurs_mai99/Reperes_bases/Bases.h
|
||||
tenseurs_mai99/Reperes_bases/Repere.cc
|
||||
tenseurs_mai99/Reperes_bases/Repere.h
|
||||
tenseurs_mai99/Tenseur/TenseurO4.h
|
||||
tenseurs_mai99/Tenseur/TenseurO4_1.cc
|
||||
tenseurs_mai99/Tenseur/TenseurO4_2.cc
|
||||
tenseurs_mai99/Tenseur/TenseurQgene-1.cc
|
||||
tenseurs_mai99/Tenseur/TenseurQgene-2.cc
|
||||
tenseurs_mai99/Vecteurs/Vecteur.c++
|
||||
tenseurs_mai99/Vecteurs/Vecteur.hc
|
||||
tenseurs_mai99/Vecteurs/Vecteur_de_pointeurs.cc
|
||||
tenseurs_mai99/Vecteurs/Vecteur_de_pointeurs.h
|
||||
tenseurs_mai99/Vecteurs/Vecteuri.cc
|
||||
tenseurs_mai99/Vecteurs/Vecteuri.h
|
||||
unix/makefile
|
||||
caneva.h
|
||||
|
||||
|
||||
715
herezh_pp/Algo/AlgoRef/Algori.cc → Algo/AlgoRef/Algori.cc
Executable file → Normal file
715
herezh_pp/Algo/AlgoRef/Algori.cc → Algo/AlgoRef/Algori.cc
Executable file → Normal file
File diff suppressed because it is too large
Load diff
70
herezh_pp/Algo/AlgoRef/Algori.h → Algo/AlgoRef/Algori.h
Executable file → Normal file
70
herezh_pp/Algo/AlgoRef/Algori.h → Algo/AlgoRef/Algori.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -80,6 +80,10 @@
|
|||
#include "Temps_CPU_HZpp.h"
|
||||
#include "TypeQuelconqueParticulier.h"
|
||||
#include "VariablesExporter.h"
|
||||
#ifdef UTILISATION_MPI
|
||||
#include "Distribution_CPU.h"
|
||||
#include "ResRaid_MPI.h"
|
||||
#endif
|
||||
|
||||
// peut-être à modifier sur linux
|
||||
#ifdef BIBLIOTHEQUE_STL_CODE_WARRIOR
|
||||
|
|
@ -152,7 +156,8 @@ class Algori
|
|||
Algori (EnumTypeCalcul type,const bool avec_typeDeCalcul
|
||||
,const list <EnumSousTypeCalcul>& soustype
|
||||
,const list <bool>& avec_soustypeDeCalcul
|
||||
,UtilLecture& entreePrinc);
|
||||
,UtilLecture& entreePrinc
|
||||
);
|
||||
|
||||
// constructeur de copie
|
||||
Algori (const Algori& algo);
|
||||
|
|
@ -171,14 +176,16 @@ class Algori
|
|||
static Algori* New_Agori(EnumTypeCalcul type,const bool avec_typeDeCalcul
|
||||
,const list <EnumSousTypeCalcul>& soustype
|
||||
,const list <bool>& avec_soustypeDeCalcul
|
||||
,UtilLecture& entreePrinc);
|
||||
,UtilLecture& entreePrinc
|
||||
);
|
||||
// ramène un tableau de pointeurs sur tous les algorithmes spécifique existants
|
||||
// IMPORTANT : il y a création des algorithmes (utilisation d'un new)
|
||||
static Tableau <Algori *> New_tous_les_Algo
|
||||
(const bool avec_typeDeCalcul
|
||||
,const list <EnumSousTypeCalcul>& soustype
|
||||
,const list <bool>& avec_soustypeDeCalcul
|
||||
,UtilLecture& entreePrinc);
|
||||
,UtilLecture& entreePrinc
|
||||
);
|
||||
|
||||
//lecture des parametres de controle
|
||||
// peut être modifié dans le cas d'un algo particulier
|
||||
|
|
@ -303,12 +310,12 @@ class Algori
|
|||
// type_incre :signal permet de localiser le dernier incrément
|
||||
virtual void Ecriture_base_info
|
||||
(int cas,LesMaillages *lesMaillages,
|
||||
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
|
||||
LesFonctions_nD* lesFonctionsnD,
|
||||
LesLoisDeComp* lesLoisDeComp,
|
||||
DiversStockage* diversStockage,Charge* charge,
|
||||
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
|
||||
OrdreVisu::EnumTypeIncre type_incre,int incre = 0);
|
||||
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
|
||||
LesFonctions_nD* lesFonctionsnD,
|
||||
LesLoisDeComp* lesLoisDeComp,
|
||||
DiversStockage* diversStockage,Charge* charge,
|
||||
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
|
||||
OrdreVisu::EnumTypeIncre type_incre,int incre = 0);
|
||||
// cas d'un démarrage à partir de base_info
|
||||
// éventuellement est définit de manière spécifique pour chaque algorithme
|
||||
// dans les classes filles
|
||||
|
|
@ -316,13 +323,14 @@ class Algori
|
|||
// incrément voulu et qu'il faut simplement faire la lecture des infos
|
||||
// cas = 3 : on met à jour uniquement les données variables, il y a modification des grandeurs,
|
||||
// mais pas redimentionnement lorsque cela est viable (sinon on redimentionne)
|
||||
virtual void Lecture_base_info(int cas,LesMaillages *lesMaillages,
|
||||
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
|
||||
LesFonctions_nD* lesFonctionsnD,
|
||||
LesLoisDeComp* lesLoisDeComp,
|
||||
DiversStockage* diversStockage,Charge* charge,
|
||||
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
|
||||
int inc_voulu=0);
|
||||
virtual void Lecture_base_info
|
||||
(int cas,LesMaillages *lesMaillages,
|
||||
LesReferences* lesReferences,LesCourbes1D* lesCourbes1D,
|
||||
LesFonctions_nD* lesFonctionsnD,
|
||||
LesLoisDeComp* lesLoisDeComp,
|
||||
DiversStockage* diversStockage,Charge* charge,
|
||||
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
|
||||
int inc_voulu=0);
|
||||
|
||||
// visualisation intéractive via le standard vrml
|
||||
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
|
||||
|
|
@ -444,6 +452,11 @@ class Algori
|
|||
streampos Debut_increment() const {return debut_increment;};
|
||||
|
||||
// ==============VARIABLES PROTEGEES :
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul parallèle
|
||||
Distribution_CPU distribution_CPU_algo; // gestion de la distribution de charge sur CPU
|
||||
#endif
|
||||
|
||||
// 1)----------- protégées: spécifiques à un algo ----------
|
||||
int mode_debug; // permet de spécifier des options particulières pour débugger
|
||||
// controle de la sortie des informations: utilisé par les classes dérivées
|
||||
|
|
@ -530,6 +543,16 @@ class Algori
|
|||
// variables privées internes servant au pilotage de la convergence
|
||||
int PhaseDeConvergence() const {return phase_de_convergence;}; // pour l'acces en lecture uniquement
|
||||
void Change_PhaseDeConvergence(int phase) {phase_de_convergence=phase;};
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul parallèle
|
||||
void Passage_indicConvergenceAuxProcCalcul() ; // passage des indicateurs aux process de calcul
|
||||
// globalisation des grandeurs globales: proc de calcul -> maitre puis transmission à ParaGlob
|
||||
// et transmission aux proc de calcul:
|
||||
// on ne demande pas à ParaGlob de faire la transmission, car il ne sait pas ce qu'il transmet
|
||||
// et les infos ne sont pas contigües, le transfert ne sera pas performant
|
||||
void Globalisation_et_transfert_auxProcCalcul_grandeurs_globales();
|
||||
#endif
|
||||
private :
|
||||
int phase_de_convergence; // =0 indique si l'on est en phase de convergence
|
||||
// =1 on a convergé soit très bien soit correctement
|
||||
|
|
@ -716,6 +739,12 @@ class Algori
|
|||
Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
|
||||
Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
|
||||
Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul parallèle: // passage des infos entre process
|
||||
Temps_CPU_HZpp temps_transfert_court ; // lesTempsCpu(17)
|
||||
Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
|
||||
Temps_CPU_HZpp temps_attente ; // lesTempsCpu(18)
|
||||
#endif
|
||||
|
||||
Tableau <Coordonnee3> lesTempsCpu; // un tableau intermédiaire qui récupère et globalise les temps pour les sorties
|
||||
// via listeVarGlob, mais c'est les variables Temps_CPU_HZpp qui stockent
|
||||
|
|
@ -865,7 +894,7 @@ class Algori
|
|||
// nouvelle_largeur_imposee.deux = la demie largeur
|
||||
// nouvelles_largeur_en_ddl.trois = la demie largeur maximale pour la partie éléments finis
|
||||
// uniquement (sans les CLL)
|
||||
Tableau <Mat_abstraite* > Mise_a_jour_Choix_matriciel_contact
|
||||
void Mise_a_jour_Choix_matriciel_contact
|
||||
(Tableau <Mat_abstraite* >& tab_matglob,const Nb_assemb& nb_casAssemb
|
||||
, LesContacts*lescontacts
|
||||
,int niveau_substitution ,TroisEntiers* nouvelle_largeur_imposee = NULL);
|
||||
|
|
@ -1032,7 +1061,9 @@ class Algori
|
|||
// mise à jour de la viscosité critique en continu: spécifique au algo de relaxation dynamique, appelé par Cal_mat_visqueux_num_expli
|
||||
void CalculEnContinuMatriceViscositeCritique(const Mat_abstraite& mat_mass,Mat_abstraite& mat_C_pt
|
||||
,const Vecteur & delta_X, const Vecteur & vitesse);
|
||||
|
||||
protected:
|
||||
|
||||
// passage des grandeurs gérées par l'algorithme de tdt à t
|
||||
// en particulier les énergies et les puissances
|
||||
void TdtversT();
|
||||
|
|
@ -1082,7 +1113,8 @@ class Algori
|
|||
|
||||
// passage des grandeurs globales aux noeuds où il y a des variables globales attachées
|
||||
// nb_casAssemb correspond au cas d'assemblage de X1
|
||||
void Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(LesMaillages * lesMail,VariablesExporter* varExpor,const Nb_assemb& nb_casAssemb,const LesReferences& lesRef);
|
||||
void Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales
|
||||
(LesMaillages * lesMail,VariablesExporter* varExpor,const Nb_assemb& nb_casAssemb,const LesReferences& lesRef);
|
||||
|
||||
// des fonctions inlines pour mettre à jour des grandeurs globales
|
||||
// -- initialisation du compteur d'itérations
|
||||
157
herezh_pp/Algo/AlgoRef/Algori2.cc → Algo/AlgoRef/Algori2.cc
Executable file → Normal file
157
herezh_pp/Algo/AlgoRef/Algori2.cc → Algo/AlgoRef/Algori2.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -64,8 +64,9 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
|
|||
{bool inc_trouve = entreePrinc->Positionnement_base_info(inc_voulu);
|
||||
if (!inc_trouve)
|
||||
{ cout << "\nErreur : On ne trouve pas l'increment de restart demande !\n";
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " increment = " << inc_voulu << endl;
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " increment = " << inc_voulu << endl;
|
||||
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||||
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
|
||||
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
|
||||
|
|
@ -108,8 +109,9 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
|
|||
// dans le cas où on n'a pas trouvé le bon incrément message d'erreur
|
||||
if (!inc_trouve)
|
||||
{ cout << "\nErreur : On ne trouve pas l'increment demande !\n";
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " incrément = " << inc_voulu << endl;
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " incrément = " << inc_voulu << endl;
|
||||
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||||
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
|
||||
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
|
||||
|
|
@ -119,8 +121,9 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
|
|||
}
|
||||
default :
|
||||
{ cout << "\nErreur : valeur incorrecte du type de restart !\n";
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " cas= " << cas << endl;
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
cout << "Algori::Lecture_base_info(....)"
|
||||
<< " cas= " << cas << endl;
|
||||
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||||
if (tempsInitialisation.Comptage_en_cours()) tempsInitialisation.Arret_du_comptage();
|
||||
if (tempsMiseAjourAlgo.Comptage_en_cours()) tempsMiseAjourAlgo.Arret_du_comptage();
|
||||
|
|
@ -131,7 +134,10 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
|
|||
|
||||
// lecture particulière à l'algorithme
|
||||
Lecture_base_info(*entrons,cas);
|
||||
// ******* reste lescontacts
|
||||
#ifdef UTILISATION_MPI
|
||||
// si calcul on sauvegarde la distribution
|
||||
distribution_CPU_algo.Lecture_base_info(*entrons,cas);
|
||||
#endif
|
||||
lesMaillages->Lecture_base_info(*entrons,cas); // lecture des maillages et des references
|
||||
lesReferences->Lecture_base_info(*entrons,cas); // lecture des références
|
||||
lesCourbes1D->Lecture_base_info(*entrons,cas); // lecture des courbes1D
|
||||
|
|
@ -242,8 +248,9 @@ void Algori::Ecriture_base_info
|
|||
}
|
||||
default :
|
||||
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
|
||||
cout << "Algori::Ecriture_base_info(....)"
|
||||
<< " cas= " << cas << endl;
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
cout << "Algori::Ecriture_base_info(....)"
|
||||
<< " cas= " << cas << endl;
|
||||
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||||
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage();
|
||||
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage();
|
||||
|
|
@ -256,6 +263,10 @@ void Algori::Ecriture_base_info
|
|||
{
|
||||
// ******* reste lescontacts
|
||||
Ecriture_base_info(*sortons,cas);
|
||||
#ifdef UTILISATION_MPI
|
||||
// si calcul on sauvegarde la distribution
|
||||
distribution_CPU_algo.Ecriture_base_info(*sortons,cas);
|
||||
#endif
|
||||
lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references
|
||||
lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references
|
||||
lesCourbes1D->Ecriture_base_info(*sortons,cas); // Ecriture des courbes1D
|
||||
|
|
@ -283,12 +294,13 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
|
||||
try
|
||||
{// écriture de l'en-tête
|
||||
cout << "\n ======== module de visualisation format vrml ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== module de visualisation format vrml ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe l'instance de visualisation de la liste des incréments possibles
|
||||
|
|
@ -377,7 +389,8 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
// entreePrinc->Fermeture_fichier_legende_vrml();
|
||||
}
|
||||
// fin de la visualisation
|
||||
cout << "\n ======== fin du module de visualisation format vrml ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format vrml ========\n";
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
|
|
@ -388,7 +401,8 @@ void Algori::Visu_vrml(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format vrml";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_vrml(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::Visu_vrml(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -406,12 +420,13 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
|
|||
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
|
||||
try
|
||||
{// écriture de l'en-tête
|
||||
cout << "\n ======== module de visualisation par fichiers de points au format maple ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== module de visualisation par fichiers de points au format maple ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe l'instance de visualisation de la liste des incréments possibles
|
||||
|
|
@ -509,7 +524,8 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
|
|||
// entreePrinc->Fermeture_fichier_principal_maple();
|
||||
}
|
||||
// fin de la visualisation
|
||||
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
|
|
@ -520,7 +536,8 @@ void Algori::Visu_maple(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefer
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format maple";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_maple(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::Visu_maple(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -538,12 +555,13 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
|
|||
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
|
||||
try
|
||||
{// écriture de l'en-tête
|
||||
cout << "\n ======== module de visualisation format geomview ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== module de visualisation format geomview ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe l'instance de visualisation de la liste des incréments possibles
|
||||
|
|
@ -656,7 +674,8 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
|
|||
// entreePrinc->Fermeture_fichier_legende_geomview();
|
||||
}
|
||||
// fin de la visualisation
|
||||
cout << "\n ======== fin du module de visualisation format geomview ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format geomview ========\n";
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
|
|
@ -667,7 +686,8 @@ void Algori::Visu_geomview(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRe
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format geomview";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_geomview(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::Visu_geomview(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -685,12 +705,13 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
|
|||
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
|
||||
try
|
||||
{// écriture de l'en-tête
|
||||
cout << "\n ======== module de visualisation format Gid ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== module de visualisation format Gid ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe l'instance de visualisation de la liste des incréments possibles
|
||||
|
|
@ -809,7 +830,8 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
|
|||
// entreePrinc->Fermeture_fichier_resultat_Gid();
|
||||
}
|
||||
// fin de la visualisation
|
||||
cout << "\n ======== fin du module de visualisation format GID ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format GID ========\n";
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
|
|
@ -820,7 +842,8 @@ void Algori::Visu_Gid(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesReferen
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format GID";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_Gid(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::Visu_Gid(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -838,12 +861,13 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
{ // on gère les exceptions éventuelles en mettant le bloc sous surveillance
|
||||
try
|
||||
{// écriture de l'en-tête
|
||||
cout << "\n ======== module de visualisation format Gmsh ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== module de visualisation format Gmsh ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe l'instance de visualisation de la liste des incréments possibles
|
||||
|
|
@ -963,7 +987,8 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
|
||||
}
|
||||
// fin de la visualisation
|
||||
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
|
|
@ -974,7 +999,8 @@ void Algori::Visu_Gmsh(ParaGlob * paraGlob,LesMaillages * lesMaillages,LesRefere
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation interactive via le format Gmsh";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::Visu_Gmsh(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::Visu_Gmsh(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -999,12 +1025,13 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
return;
|
||||
}
|
||||
// écriture de l'en-tête
|
||||
cout << "\n ======== lecture du fichier de commande de visualisation ========\n";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== lecture du fichier de commande de visualisation ========\n";
|
||||
// -- on définit l'ensemble des incréments possibles, ceci sont stocké dans .BI
|
||||
// tout d'abord ouverture du fichier de restart si nécessaire
|
||||
entreePrinc->Ouverture_base_info("lecture");
|
||||
// récup du flot d'entrée
|
||||
ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// ifstream * entrons = entreePrinc->Ent_BI();
|
||||
// def du conteneur des numéros d'incréments
|
||||
list <int> list_incre = entreePrinc->Liste_increment();
|
||||
// on informe les instances de visualisation de la liste des incréments possibles
|
||||
|
|
@ -1032,7 +1059,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
{ // cas où pas de liste -> on initialise à 0 et au dernier incrément si différent
|
||||
list_incre_init_inter = &(visualise.List_balaie_init(-1));
|
||||
}
|
||||
const list<int> & list_incre_init = * list_incre_init_inter;
|
||||
// const list<int> & list_incre_init = * list_incre_init_inter;
|
||||
// on impose la liste pour les autres types de visualisation
|
||||
visualise_maple.List_balaie_init(*list_incre_init_inter);//list_incre_init);
|
||||
visualise_geomview.List_balaie_init(*list_incre_init_inter);//list_incre_init);
|
||||
|
|
@ -1123,14 +1150,14 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
<< " fin_fichier_commande_visu ! "
|
||||
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
|
||||
<< "\n il y a peut-etre un probleme";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::LectureCommandeVisu(..";
|
||||
}
|
||||
else
|
||||
{ // erreur en lecture
|
||||
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
|
||||
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::LectureCommandeVisu(..";
|
||||
}
|
||||
}
|
||||
|
|
@ -1143,12 +1170,13 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
catch (...)// erreur inconnue
|
||||
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
|
||||
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::LectureCommandeVisu(..";
|
||||
};
|
||||
|
||||
// avertissement de la fin de lecture du fichier de commande
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
// if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
|
||||
// visualisation en fonction de l'activité des différents types de sortie
|
||||
// récup de la list des incréments à balayer
|
||||
|
|
@ -1268,7 +1296,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
// entreePrinc->Fermeture_fichier_principal_vrml();
|
||||
// entreePrinc->Fermeture_fichier_legende_vrml();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format vrml ========\n";
|
||||
}
|
||||
if (visualise_maple.Visu_maple_valide())
|
||||
|
|
@ -1278,7 +1306,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
|
||||
// entreePrinc->Fermeture_fichier_principal_maple();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
|
||||
}
|
||||
if (visualise_geomview.Visu_geomview_valide())
|
||||
|
|
@ -1288,7 +1316,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
// entreePrinc->Fermeture_fichier_principal_geomview();
|
||||
// entreePrinc->Fermeture_fichier_legende_geomview();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format geomview ========\n";
|
||||
}
|
||||
if (visualise_Gid.Visu_Gid_valide())
|
||||
|
|
@ -1298,7 +1326,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
// entreePrinc->Fermeture_fichier_initial_Gid();
|
||||
// entreePrinc->Fermeture_fichier_resultat_Gid();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format Gid ========\n";
|
||||
}
|
||||
if (visualise_Gmsh.Visu_Gmsh_valide())
|
||||
|
|
@ -1308,7 +1336,7 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
// entreePrinc->Fermeture_fichier_initial_Gmsh();
|
||||
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
|
||||
}
|
||||
}
|
||||
|
|
@ -1321,7 +1349,8 @@ void Algori::LectureCommandeVisu(ParaGlob * paraGlob,LesMaillages * lesMaillages
|
|||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{cout << "\n **** warning: erreur inconnue en lecture du fichier commande Visu";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::LectureCommandeVisu(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::LectureCommandeVisu(..";
|
||||
cout << "endl";
|
||||
};
|
||||
};
|
||||
|
|
@ -1350,7 +1379,7 @@ void Algori::EcritureCommandeVisu()
|
|||
catch (...)// erreur en écriture
|
||||
{ cout << "\n **** ERREUR en ecriture du fichier de commande de visualisation "
|
||||
<< "\n on continue quand meme";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::EcritureCommandeVisu(..";
|
||||
};
|
||||
};
|
||||
|
|
@ -1401,7 +1430,8 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
return;
|
||||
}
|
||||
// écriture de l'en-tête
|
||||
if (ParaGlob::NiveauImpression() >= 2) {cout << "\n ======== lecture du fichier de commande "
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 1)) || (permet_affichage > 2))
|
||||
{cout << "\n ======== lecture du fichier de commande "
|
||||
<< "de visualisation ========\n";
|
||||
};
|
||||
//-- initialisation des grandeurs globales par maillage
|
||||
|
|
@ -1515,19 +1545,19 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
<< " fin_fichier_commande_visu ! "
|
||||
<< "\n normalement ce mot cle doit finir le fichier, on continue quand meme, mais"
|
||||
<< "\n il y a peut-etre un probleme";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
}
|
||||
else if ( erreur.lecture == 0) // on ne peut pas ouvrir le fichier
|
||||
{ cout << "\n **** erreur en ouverture du fichier ";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
}
|
||||
else
|
||||
{ // erreur en lecture
|
||||
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
|
||||
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
}
|
||||
}
|
||||
|
|
@ -1540,11 +1570,12 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
catch (...)// erreur inconnue
|
||||
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
|
||||
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
|
||||
if (ParaGlob::NiveauImpression() >= 4)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
}
|
||||
// avertissement de la fin de lecture du fichier de commande
|
||||
if (ParaGlob::NiveauImpression() >= 2)
|
||||
// if (ParaGlob::NiveauImpression() >= 2)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin de la lecture du fichier de commande de visualisation ========\n";
|
||||
// initialisation de la sortie vrml (fichier) si la sortie vrml est valide
|
||||
if (visualise.Visu_vrml_valide())
|
||||
|
|
@ -1675,7 +1706,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
// entreePrinc->Fermeture_fichier_principal_vrml();
|
||||
// entreePrinc->Fermeture_fichier_legende_vrml();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format vrml ========\n";
|
||||
};
|
||||
if (visualise_maple.Visu_maple_valide())
|
||||
|
|
@ -1685,7 +1716,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
// // on ferme la sortie maple (fichier) et appel éventuel du visualisateur
|
||||
// entreePrinc->Fermeture_fichier_principal_maple();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin module de visualisation par fichiers de points au format maple ========\n";
|
||||
};
|
||||
if (visualise_geomview.Visu_geomview_valide())
|
||||
|
|
@ -1695,7 +1726,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
// entreePrinc->Fermeture_fichier_principal_geomview();
|
||||
// entreePrinc->Fermeture_fichier_legende_geomview();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format geomview ========\n";
|
||||
};
|
||||
if (visualise_Gid.Visu_Gid_valide())
|
||||
|
|
@ -1705,7 +1736,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
// entreePrinc->Fermeture_fichier_initial_Gid();
|
||||
// entreePrinc->Fermeture_fichier_resultat_Gid();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format Gid ========\n";
|
||||
};
|
||||
if (visualise_Gmsh.Visu_Gmsh_valide())
|
||||
|
|
@ -1715,7 +1746,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
// entreePrinc->Fermeture_fichier_initial_Gmsh();
|
||||
// entreePrinc->Fermeture_TousLesFichiersResultats_Gmsh();
|
||||
// fin de la visualisation
|
||||
if (ParaGlob::NiveauImpression() >= 0)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
cout << "\n ======== fin du module de visualisation format Gmsh ========\n";
|
||||
};
|
||||
}; //-- fin du if (type_incre == OrdreVisu::DERNIER_INCRE)
|
||||
|
|
@ -1728,9 +1759,10 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
|
|||
throw (toto);
|
||||
}
|
||||
catch ( ... )
|
||||
{ if (ParaGlob::NiveauImpression() >= 1)
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
{cout << "\n **** warning: erreur en ecriture pour la visualisation au fil du calcul";
|
||||
if (ParaGlob::NiveauImpression() >= 4) cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
cout << "\n Algori::VisuAuFilDuCalcul(..";
|
||||
cout << endl;
|
||||
};
|
||||
};
|
||||
|
|
@ -1860,6 +1892,11 @@ void Algori::Ecriture_base_info
|
|||
sort << "\n tps_metrique_KSM "<< temps_metrique_K_SM;
|
||||
sort << "\n tps_chargement "<< temps_chargement;
|
||||
sort << "\n tps_rech_contact "<< temps_rech_contact;
|
||||
#ifdef UTILISATION_MPI
|
||||
sort << "\n tps_transfert_court_proc "<< temps_transfert_court;
|
||||
sort << "\n tps_transfert_long_proc "<< temps_transfert_long;
|
||||
sort << "\n tps_attente_proc "<< temps_attente;
|
||||
#endif
|
||||
|
||||
// ----- écriture éventuelle des paramètres de l'algorithme et informations particulières
|
||||
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
|
||||
|
|
@ -2046,7 +2083,11 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
|
|||
ent >> nom1 >> temps_metrique_K_SM;
|
||||
ent >> nom1 >> temps_chargement;
|
||||
ent >> nom1 >> temps_rech_contact;
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
ent >> nom1 >> temps_transfert_court;
|
||||
ent >> nom1 >> temps_transfert_long;
|
||||
ent >> nom1 >> temps_attente;
|
||||
#endif
|
||||
|
||||
// --- lecture éventuelle des paramètres de l'algorithme
|
||||
// on regarde tout d'abord si l'algo en lecture correspond
|
||||
77
herezh_pp/Algo/AlgoRef/Algori3.cc → Algo/AlgoRef/Algori3.cc
Executable file → Normal file
77
herezh_pp/Algo/AlgoRef/Algori3.cc → Algo/AlgoRef/Algori3.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -1189,7 +1189,8 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
|
|||
if (fct_nD_inter_nb_entre_relax != NULL)
|
||||
{int old_valeur = inter_nb_entre_relax;
|
||||
inter_nb_entre_relax = (fct_nD_inter_nb_entre_relax->Valeur_pour_variables_globales())(1);
|
||||
if ((ParaGlob::NiveauImpression() > 2) && (old_valeur != inter_nb_entre_relax))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 1))
|
||||
if (old_valeur != inter_nb_entre_relax)
|
||||
cout << "\n >>> changement de inter_nb_entre_relax de " << old_valeur
|
||||
<< " en ==> "<< inter_nb_entre_relax;
|
||||
};
|
||||
|
|
@ -1252,7 +1253,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
|
|||
else {moy_gliss_t= 0.; moyenne_glissante = 0.;}; // au cas où on met une valeur très grande
|
||||
};
|
||||
// écriture d'info pour le débug au cas où
|
||||
if ((ParaGlob::NiveauImpression() > 6) || (permet_affichage >3 ))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 6)) || (permet_affichage > 3))
|
||||
{if (taille_moyenne_glissante == 1)
|
||||
{cout << "\n E_cin_tdt= " << E_cin_tdt << " compteur_decroit_pourRelaxDyn= " << compteur_decroit_pourRelaxDyn
|
||||
<< " pic_E_cint_t= " << pic_E_cint_t << endl;
|
||||
|
|
@ -1371,7 +1372,7 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
|
|||
{ if (delta_ddl.Max_val_abs() <= max_deltaX_pourRelaxDyn) nb_dX_OK_pourRelaxDyn++;
|
||||
if (nb_dX_OK_pourRelaxDyn > nb_max_dX_OK_pourRelaxDyn)
|
||||
{ relax_vit = -1;
|
||||
if (ParaGlob::NiveauImpression() > 6)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 6)) || (permet_affichage > 3))
|
||||
cout << "\n critere en deplacement ok: max_deltaX= " << delta_ddl.Max_val_abs();
|
||||
nb_dX_OK_pourRelaxDyn=0; // on initialise pour une prochaine fois
|
||||
// dans le cas ou l'arrêt réel n'est pas drivé par le déplacement
|
||||
|
|
@ -1385,7 +1386,8 @@ int Algori::AmortissementCinetique(const Vecteur & delta_ddl,const double& coef_
|
|||
|
||||
// on tente d'afficher que si l'amortissement a effectivement eu lieu
|
||||
// if (relax_vit && pa.AfficheIncrEnergie())
|
||||
if (relaxation_effectuee && ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0)))
|
||||
if (relaxation_effectuee)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 2))
|
||||
{cout << "\n N:" << icharge << " relaxation cinetique effectuee "
|
||||
<< " pic_E_cint_t("<<compteur_pic_energie<<") " << dernier_pic
|
||||
<< " max_pic_E_cin= " << max_pic_E_cin;
|
||||
|
|
@ -1562,7 +1564,8 @@ int Algori::AmortissementCinetique_individuel_aux_noeuds(const Vecteur & delta_d
|
|||
// }
|
||||
//// fin debug
|
||||
// on tente d'afficher que si l'amortissement a effectivement eu lieu
|
||||
if (relaxation_effectuee && (ParaGlob::NiveauImpression() > 7))
|
||||
if (relaxation_effectuee)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 7)) || (permet_affichage > 5))
|
||||
{cout << "\n relax effectue au noeud " << noe
|
||||
<< " pic_eN_cint_t("<<compteur_pic_energie_noe<<") " << dernier_pic_eN
|
||||
<< " max_pic_eN_cin= " << max_pic_eN_cin;
|
||||
|
|
@ -1573,8 +1576,9 @@ int Algori::AmortissementCinetique_individuel_aux_noeuds(const Vecteur & delta_d
|
|||
cout << endl;
|
||||
};
|
||||
}; // fin de la boucle sur les noeuds
|
||||
if ((ParaGlob::NiveauImpression() > 4)&&(compteur_relaxation_ok>0)) // affichage global éventuel
|
||||
cout << "\n nb de relaxation individuelle effectuee: " << compteur_relaxation_ok;
|
||||
if (compteur_relaxation_ok>0) // affichage global éventuel
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 4)) || (permet_affichage > 2))
|
||||
cout << "\n nb de relaxation individuelle effectuee: " << compteur_relaxation_ok;
|
||||
|
||||
};// -- fin du cas où l'on applique l'amortissement
|
||||
|
||||
|
|
@ -1735,7 +1739,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
else if (compteur > pa.Iterations())
|
||||
{ nombre_de_mauvaises_convergences++;
|
||||
nombre_de_bonnes_convergences = 0;
|
||||
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n ******* NON convergence des iterations d'equilibre ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1750,7 +1754,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
}
|
||||
else if (phase_de_convergence == -2) // cas où c'est Convergence() qui est la cause de l'arret
|
||||
// pour cause d'évolution divergente des résidus
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence equilibre: evolution divergente des residus ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1766,7 +1770,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
}
|
||||
else if (phase_de_convergence == -3) // cas où c'est Convergence() qui est la cause de l'arret
|
||||
// pour cause de variation de ddl minimal atteinte
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence equilibre: variation de ddl minimal atteinte ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1782,7 +1786,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
}
|
||||
else if (phase_de_convergence == -4) // cas où c'est Convergence() qui est la cause de l'arret
|
||||
// pour cause de variation de ddl maximal atteinte
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence equilibre: variation de ddl maximum atteinte ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1797,7 +1801,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
fin_iter = false; // on signale qu'il n'y a pas convergence
|
||||
}
|
||||
else if (phase_de_convergence == -5) // cas d'un arrêt à cause d'un jacobien négatif, qui est géré
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence due a la gestion de jacobien negatif ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1812,7 +1816,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else if (phase_de_convergence == -6) // cas d'un arrêt à cause d'une variation de jacobine trop grande
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence due a une variation de jacobien trop grande ********* "
|
||||
<< "\n============================================================================";
|
||||
|
|
@ -1827,7 +1831,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else if (phase_de_convergence == -7) // cas d'un arrêt à cause d'une non convergence de la loi de comp
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence due a la loi de comportement ********* "
|
||||
|
|
@ -1845,7 +1849,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
}
|
||||
else if (phase_de_convergence == -8) // cas d'un arrêt à cause d'une non convergence de la loi de comp
|
||||
// mais pour un pb qui couve depuis plusieurs incréments
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{ cout << "\n============================================================================"
|
||||
<< "\n *** NON convergence du a la loi de comportement ********* "
|
||||
|
|
@ -1864,7 +1868,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else if (phase_de_convergence == -9) // cas d'un arrêt à cause d'un pb de la résolution du syteme linéaire
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{ cout << "\n=============================================================================="
|
||||
<< "\n *** NON convergence due a un pb de resolution du systeme lineaire ********* "
|
||||
|
|
@ -1881,7 +1885,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else if (phase_de_convergence == -10) // cas d'un arrêt à cause d'un pb de calcul des efforts extérieurs
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{ cout << "\n=============================================================================="
|
||||
<< "\n *** NON convergence due a un pb de calcul des efforts exterieurs ********* "
|
||||
|
|
@ -1898,7 +1902,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else if (phase_de_convergence == -11) // cas d'un arrêt à cause d'un nan ou infini sur forces ext, int
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{ cout << "\n=============================================================================="
|
||||
<< "\n *** NON convergence due a un nan ou infini sur forces int, ext, totales ********* "
|
||||
|
|
@ -1915,7 +1919,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
nombre_de_mauvaises_convergences++;
|
||||
}
|
||||
else // cas d'une erreur de pilotage: on ne sait pas pourquoi il s'est arrêté sans convergence
|
||||
{ if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{ if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n cas de pilotage de fin d'iteration inconnues ? ou alors qui suit une erreur signalee precedemment ";
|
||||
if (ParaGlob::NiveauImpression() > 5)
|
||||
|
|
@ -1940,7 +1944,7 @@ bool Algori::Pilotage_fin_iteration_implicite(int compteur)
|
|||
}
|
||||
return fin_iter;
|
||||
//debug
|
||||
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n Algori::Pilotage_fin_iteration_implicite: phase_de_convergence=" << phase_de_convergence
|
||||
<< " nombre_de_bonnes_convergences= " << nombre_de_bonnes_convergences
|
||||
<< " nombre_de_mauvaises_convergences " << nombre_de_mauvaises_convergences << endl ;
|
||||
|
|
@ -2029,7 +2033,8 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
|
|||
{ // -- sur ou sous relaxation
|
||||
double sursousrelax = pa.SurSousRelaxation();
|
||||
(*sol) *= sursousrelax;
|
||||
if ((ParaGlob::NiveauImpression() >= 4) && (sursousrelax != 1.))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 3)) || (permet_affichage > 2))
|
||||
if (sursousrelax != 1.)
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n intervention d'une sur-sous relaxation: ";}
|
||||
else {cout << "\n intervention of an over or under relaxation: ";};
|
||||
|
|
@ -2041,7 +2046,7 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
|
|||
{// cas d'une limitation globale (tout le vecteur sol change
|
||||
if (maxDeltaDdl > pa.NormeMax_increment())
|
||||
{ double facteur=(pa.NormeMax_increment()/maxDeltaDdl);
|
||||
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur increment de ddl ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector increment of dof ";};
|
||||
|
|
@ -2064,7 +2069,7 @@ void Algori::Pilotage_chaque_iteration(Vecteur* sol,double& maxDeltaDdl,const in
|
|||
{ vect(i) = Signe(vect(i),maxa); modif = true;};
|
||||
};
|
||||
if (modif)
|
||||
{if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur increment de ddl, limitation des maxis ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector increment of dof, limitation of the maxis ";};
|
||||
|
|
@ -2114,7 +2119,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
|
|||
double maxDeltaDdl=vec_trav.Max_val_abs();
|
||||
if (maxDeltaDdl > normeMax_X_increment)
|
||||
{ double facteur=(normeMax_X_increment/maxDeltaDdl);
|
||||
if (ParaGlob::NiveauImpression() > 2)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta X ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta X ";};
|
||||
|
|
@ -2139,7 +2144,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
|
|||
{ vec_trav(i) = Signe(vec_trav(i),maxa); modif = true;};
|
||||
};
|
||||
if (modif)
|
||||
{if (ParaGlob::NiveauImpression() > 2)
|
||||
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta X, limitation des maxis ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta X, limitation of the maxis ";};
|
||||
|
|
@ -2159,7 +2164,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
|
|||
double maxDeltaDdl=vec_trav.Max_val_abs();
|
||||
if (maxDeltaDdl > normeMax_V_increment)
|
||||
{ double facteur=(normeMax_V_increment/maxDeltaDdl);
|
||||
if (ParaGlob::NiveauImpression() > 2)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta V ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta V ";};
|
||||
|
|
@ -2184,7 +2189,7 @@ void Algori::Pilotage_maxi_X_V(const Vecteur& X_t,Vecteur& X_tdt,const Vecteur&
|
|||
{ vec_trav(i) = Signe(vec_trav(i),maxa); modif = true;};
|
||||
};
|
||||
if (modif)
|
||||
{if (ParaGlob::NiveauImpression() > 4)
|
||||
{if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 4)) || (permet_affichage > 0))
|
||||
{if(ParaGlob::Francais())
|
||||
{cout << "\n ===>>>>> intervention de la reduction du vecteur delta V, limitation des maxis ";}
|
||||
else {cout << "\n ===>>>>> intervention of the reduction for the vector delta V, limitation of the maxis ";};
|
||||
|
|
@ -2222,9 +2227,15 @@ void Algori::TdtversT()
|
|||
// pour un problème de mécanique, en comparant le nombre de point d'intégration total
|
||||
// et le nombre totale de degré de liberté
|
||||
void Algori::VerifSingulariteRaideurMeca(int nbddl,const LesMaillages& lesMail) const
|
||||
{ if (ParaGlob::NiveauImpression() != 0)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, seule la matrice du CPU 0 est concernée
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
return ;
|
||||
#endif
|
||||
if (ParaGlob::NiveauImpression() != 0)
|
||||
{ // récup du nombre de grandeurs génératrices
|
||||
Enum_ddl enu(SIG11); // init par défaut
|
||||
// Enum_ddl enu(SIG11); // init par défaut
|
||||
|
||||
// on récupère la liste des problèmes physiques gérés par les éléments de tous les maillages
|
||||
const list <Enum_ddl >& li = lesMail.Ddl_representatifs_des_physiques();
|
||||
|
|
@ -2236,12 +2247,12 @@ void Algori::VerifSingulariteRaideurMeca(int nbddl,const LesMaillages& lesMail)
|
|||
// affichage
|
||||
const double ratio = 1.2; // le pourcentage
|
||||
if (nbpt < ratio * nbddl)
|
||||
if ((ParaGlob::NiveauImpression() > 0) || (permet_affichage> 0))
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0))
|
||||
{ cout << "\n *** Attention, le nombre total de grandeurs generatrices aux point d'integrations dans "
|
||||
<< " le probleme: " << nbpt << " est inferieur "
|
||||
<< " a " << ratio << " * le nombre total de ddl du probleme !! c-a-d: "<< int(ratio * nbddl)
|
||||
<< "\n en consequence il est possible que la matrice de raideur soit naturellement singuliere \n\n ";
|
||||
if (ParaGlob::NiveauImpression() > 7)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 7)) || (permet_affichage > 0))
|
||||
cout << "\n void Algori::VerifSingulariteRaideurMeca(... ";
|
||||
};
|
||||
};
|
||||
|
|
@ -2282,7 +2293,7 @@ void Algori::Coherence_Algo_typeConvergence()
|
|||
&& (Evolution_temporelle_du_calcul(typeCalcul) != AUCUNE_EVOLUTION))
|
||||
{ cout << "\n *** erreur: utilisation de la norme E_cinetique/E_statique avec un calcul non dynamique"
|
||||
<< " arret ! ";
|
||||
if (ParaGlob::NiveauImpression() > 5)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 5)) || (permet_affichage > 0))
|
||||
cout << "\n Algori::Coherence_Algo_typeConvergence() ";
|
||||
// dans le cas où un comptage du calcul est en cours on l'arrête
|
||||
if (tempsCalEquilibre.Comptage_en_cours())
|
||||
198
herezh_pp/Algo/AlgoRef/Algori4.cc → Algo/AlgoRef/Algori4.cc
Executable file → Normal file
198
herezh_pp/Algo/AlgoRef/Algori4.cc → Algo/AlgoRef/Algori4.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -421,6 +421,11 @@ void Algori::Passage_de_grandeurs_globales_vers_noeuds_pour_variables_globales(L
|
|||
// Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
|
||||
// Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
|
||||
// Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
|
||||
// si calcul //
|
||||
// Temps_CPU_HZpp temps_transfert_court; // lesTempsCpu(17)
|
||||
// Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
|
||||
// Temps_CPU_HZpp temps_attente; // lesTempsCpu(18)
|
||||
|
||||
//
|
||||
// Tableau <Coordonnee3> lesTempsCpu; // un tableau intermédiaire qui récupère et globalise les temps pour les sorties
|
||||
// // via listeVarGlob, mais c'est les variables Temps_CPU_HZpp qui stockent
|
||||
|
|
@ -475,6 +480,11 @@ void Algori::Temps_CPU_HZpp_to_lesTempsCpu
|
|||
lesTempsCpu(15)(1)= temps_chargement.Temps_CPU_User();
|
||||
temps_rech_contact = contact.Temps_cpu_Contact();
|
||||
lesTempsCpu(16)(1)= temps_rech_contact.Temps_CPU_User();
|
||||
#ifdef UTILISATION_MPI
|
||||
lesTempsCpu(17)(1)= temps_transfert_court.Temps_CPU_User();
|
||||
lesTempsCpu(19)(1)= temps_transfert_long.Temps_CPU_User();
|
||||
lesTempsCpu(18)(1)= temps_attente.Temps_CPU_User();
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -502,6 +512,11 @@ Tableau <Temps_CPU_HZpp> & Algori::Ajout_Temps_CPU_HZpp_to_lesTempsCpu(Tableau <
|
|||
lesTsCpu(8) += tempsSortieFilCalcul; // conversion de long long en double
|
||||
lesTsCpu(9) += tempsRaidSmEnerContact; // conversion de long long en double
|
||||
lesTsCpu(10) += tempsSecondMembreEnergContact; // conversion de long long en double
|
||||
#ifdef UTILISATION_MPI
|
||||
lesTsCpu(17) += temps_transfert_court;
|
||||
lesTsCpu(19) += temps_transfert_long;
|
||||
lesTsCpu(18) += temps_attente;
|
||||
#endif
|
||||
// retour
|
||||
return lesTsCpu;
|
||||
|
||||
|
|
@ -526,6 +541,11 @@ void Algori::Arret_du_comptage_CPU()
|
|||
temps_metrique_K_SM.Arret_du_comptage();
|
||||
temps_chargement.Arret_du_comptage();
|
||||
temps_rech_contact.Arret_du_comptage();
|
||||
#ifdef UTILISATION_MPI
|
||||
temps_transfert_court.Arret_du_comptage();
|
||||
temps_transfert_long.Arret_du_comptage();
|
||||
temps_attente.Arret_du_comptage();
|
||||
#endif
|
||||
};
|
||||
|
||||
// sortie sur fichier des temps cpu
|
||||
|
|
@ -561,7 +581,11 @@ void Algori::Sortie_temps_cpu(const LesCondLim& lesCondLim
|
|||
// écriture des temps cpu de l'algo:
|
||||
|
||||
sort_cpu << "\n==========================================================================";
|
||||
#ifndef UTILISATION_MPI
|
||||
sort_cpu << "\n Herezh++ : bilan temps cpu pour l'algorithme: " << Nom_TypeCalcul(TypeDeCalcul());;
|
||||
#else
|
||||
sort_cpu << "\n Herezh++ : (CPU "<< ParaGlob::Monde()->rank() << ") bilan temps cpu pour l'algorithme: " << Nom_TypeCalcul(TypeDeCalcul());;
|
||||
#endif
|
||||
sort_cpu << "\n==========================================================================\n";
|
||||
// puis affichage de la version
|
||||
ParaGlob::Sortie_Version(sort_cpu);
|
||||
|
|
@ -642,6 +666,20 @@ void Algori::Sortie_temps_cpu(const LesCondLim& lesCondLim
|
|||
<< "("<< std::setw(nbdigit) << (100*tempsSortieFilCalcul.Temps_CPU_User()/total_cpu) << " % ) "
|
||||
<< tempsSortieFilCalcul.Temps_CPU_User_milli()
|
||||
;
|
||||
#ifdef UTILISATION_MPI
|
||||
sort_cpu << "\n tps__transfert_cour_inter_cpu "
|
||||
<< "("<< std::setw(nbdigit) << (100*temps_transfert_court.Temps_CPU_User()/total_cpu) << " % ) "
|
||||
<< temps_transfert_court.Temps_CPU_User_milli()
|
||||
;
|
||||
sort_cpu << "\n tps__transfert_long_inter_cpu "
|
||||
<< "("<< std::setw(nbdigit) << (100*temps_transfert_long.Temps_CPU_User()/total_cpu) << " % ) "
|
||||
<< temps_transfert_long.Temps_CPU_User_milli()
|
||||
;
|
||||
sort_cpu << "\n tps__attente_inter_cpu "
|
||||
<< "("<< std::setw(nbdigit) << (100*temps_attente.Temps_CPU_User()/total_cpu) << " % ) "
|
||||
<< temps_attente.Temps_CPU_User_milli()
|
||||
;
|
||||
#endif
|
||||
sort_cpu << "\n";
|
||||
};
|
||||
|
||||
|
|
@ -856,16 +894,19 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
|
|||
,LesCondLim* lesCondLim,LesReferences* lesRef
|
||||
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
|
||||
,LesContacts* lescontacts,int niveau_substitution)
|
||||
{ // --- calcul des éléments de contact: (correspond à la définition de la surface de contact)
|
||||
// definition ou mise à jour, des elements de contact eventuels
|
||||
// - imposition (en fonction de l'algorithme de contact) de conditions particulières de penetration (nulle par exemple)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, seule la (ou les) matrices du CPU 0 sont concernées
|
||||
// donc s'il s'agit d'un CPU différent, on revient immédiatement
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
return false;
|
||||
#endif
|
||||
|
||||
TroisEntiers nevez_largeurs;
|
||||
bool retour = false; // init pas de changement a priori au niveau des matrices
|
||||
if (premier_calcul)
|
||||
{// si demandé, renumérotation en fonction des éléments en contact
|
||||
if ((ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
|| (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
)
|
||||
if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
{ // récup des connexions entre noeud dues aux contacts
|
||||
const Tableau <Condilineaire>& tabCondLine= lescontacts->ConnectionCLL();
|
||||
if (tabCondLine.Taille() > 0) //cas où il faut en tenir compte
|
||||
|
|
@ -873,7 +914,7 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
|
|||
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->ConnectionCLL(lesMail,lesRef));
|
||||
int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
|
||||
tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
|
||||
if (ParaGlob::NiveauImpression() >= 3)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
|
||||
cout << "\n -- renumerotation en tenant compte des elements de contact ";
|
||||
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
|
||||
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
|
||||
|
|
@ -902,9 +943,7 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
|
|||
} //-- fin du cas si premier calcul
|
||||
else
|
||||
{if (nouvelle_situation_contact)
|
||||
{if ((ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
|| (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
)
|
||||
{if (ParaGlob::param->ParaAlgoControleActifs().Optimisation_numerotation())
|
||||
{ // récup des connexions entre noeud dues aux contacts
|
||||
const Tableau <Condilineaire>& tabCondLine= lescontacts->ConnectionCLL();
|
||||
if (tabCondLine.Taille() > 0) //cas où il faut en tenir compte
|
||||
|
|
@ -913,8 +952,8 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
|
|||
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->Tab_CLinApplique());
|
||||
int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
|
||||
tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
|
||||
if (ParaGlob::NiveauImpression() >= 3)
|
||||
cout << "\n -- renumerotation en tenant compte des elements de contact ";
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
|
||||
cout << "\n -- renumerotation en tenant compte d'un changement de contact ";
|
||||
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
|
||||
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
|
||||
if (calcul_ok) // cas où il y a eu effectivement un changement de numérotation
|
||||
|
|
@ -968,7 +1007,15 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
|
|||
,LesCondLim* lesCondLim,LesReferences* lesRef
|
||||
,Tableau <Mat_abstraite* >& tab_mato,const Nb_assemb& nb_casAssemb
|
||||
,int niveau_substitution)
|
||||
{ TroisEntiers nevez_largeurs;
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, seule la (ou les) matrices du CPU 0 sont concernées
|
||||
// donc s'il s'agit d'un CPU différent, on revient immédiatement
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
return false;
|
||||
#endif
|
||||
|
||||
TroisEntiers nevez_largeurs;
|
||||
bool retour = false; // init pas de changement a priori au niveau des matrices
|
||||
if (premier_calcul)
|
||||
{// si demandé, renumérotation des pointeurs d'assemblage
|
||||
|
|
@ -977,7 +1024,7 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
|
|||
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->ConnectionCLL(lesMail,lesRef));
|
||||
// int tailtabCLL = tabCLL.Taille();tabCLL.Change_taille(tailtabCLL+1);
|
||||
// tabCLL(tailtabCLL+1) = tabCondLine; // ajout de la partie contact
|
||||
if (ParaGlob::NiveauImpression() >= 3)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
|
||||
cout << "\n -- renumerotation des pointeurs d'assemblage en tenant compte des CLL ";
|
||||
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
|
||||
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
|
||||
|
|
@ -1001,7 +1048,7 @@ bool Algori::Gestion_stockage_et_renumerotation_sans_contact(LesContacts* lesco
|
|||
{ // récup des connexions entre noeuds dues aux CLL externes: comme les cll ont été mises à jour
|
||||
// on récupère directement le tableau
|
||||
Tableau <Tableau <Condilineaire> > tabCLL(lesCondLim->Tab_CLinApplique());
|
||||
if (ParaGlob::NiveauImpression() >= 3)
|
||||
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 2)) || (permet_affichage > 2))
|
||||
cout << "\n -- renumerotation des pointeurs d'assemblage en tenant compte des CLL ";
|
||||
// appel de l'utilitaire dans lesMaillages: avec mise à jour dans la foulée de l'assemblage
|
||||
bool calcul_ok = lesMail->Renumerotation(*lesRef,tabCLL,nevez_largeurs,&nb_casAssemb,true);
|
||||
|
|
@ -1046,7 +1093,8 @@ void Algori::Cal_Transfert_delta_et_var_X(double& max_delta_X, double& max_var_d
|
|||
Algori* Algori::New_Agori(EnumTypeCalcul id_TypeCalcul,const bool avec_typeDeCalcul
|
||||
,const list <EnumSousTypeCalcul>& soustype
|
||||
,const list <bool>& avec_soustypeDeCalcul
|
||||
,UtilLecture& entreePrinc)
|
||||
,UtilLecture& entreePrinc
|
||||
)
|
||||
|
||||
{ // définition du pointeur de retour
|
||||
Algori* algo_specifique;
|
||||
|
|
@ -1149,7 +1197,8 @@ Tableau <Algori *> Algori::New_tous_les_Algo
|
|||
,UtilLecture& entreePrinc)
|
||||
{ // définition du tableau de pointeurs de retour
|
||||
Tableau <Algori* > tab_algo_specifique(15);
|
||||
|
||||
// la méthode ne doit pas fonctionner dans le cas d'un calcul //
|
||||
#ifndef UTILISATION_MPI
|
||||
tab_algo_specifique(1) = new AlgoriNonDyna
|
||||
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||||
tab_algo_specifique(2) = new ImpliNonDynaCont
|
||||
|
|
@ -1180,7 +1229,118 @@ Tableau <Algori *> Algori::New_tous_les_Algo
|
|||
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||||
tab_algo_specifique(15) = new AlgoriCombine
|
||||
(avec_typeDeCalcul,soustype,avec_soustypeDeCalcul,entreePrinc);
|
||||
|
||||
#else
|
||||
// c'est une erreur
|
||||
cout << "\n *** erreur: la methode Algori::New_tous_les_Algo n'est pas prevu "
|
||||
<< " pour fonctionner en calcul parallele, veuillez utiliser la version "
|
||||
<< " mono processeur! "<< endl;
|
||||
Sortie(1);
|
||||
#endif
|
||||
|
||||
return tab_algo_specifique;
|
||||
};
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul parallèle, passage des indicateurs
|
||||
// calculés par le process 0 aux process de calcul
|
||||
void Algori::Passage_indicConvergenceAuxProcCalcul()
|
||||
{// seule le process 0 a fait la résolution globale
|
||||
// il gère seul également la convergence, mais il doit tenir au courant les autres process
|
||||
// on utilise un std::array pour passer en une fois les infos
|
||||
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
||||
std::array<int,6> indic_convergence = {phase_de_convergence,nombre_de_bonnes_convergences
|
||||
,nombre_de_mauvaises_convergences,a_converge
|
||||
,a_converge_iterMoins1,nb_cycle_test_max_var_residu
|
||||
};
|
||||
broadcast(*ParaGlob::Monde(), indic_convergence, 0);
|
||||
// ParaGlob::Monde()->barrier();
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
// on récupère les grandeurs
|
||||
{phase_de_convergence = indic_convergence[0];
|
||||
nombre_de_bonnes_convergences = indic_convergence[1];
|
||||
nombre_de_mauvaises_convergences = indic_convergence[2];
|
||||
a_converge = indic_convergence[3];
|
||||
a_converge_iterMoins1 = indic_convergence[4];
|
||||
nb_cycle_test_max_var_residu = indic_convergence[5];
|
||||
};
|
||||
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
|
||||
};
|
||||
// globalisation des grandeurs globales: proc de calcul -> maitre puis transmission à ParaGlob
|
||||
// et transmission aux proc de calcul:
|
||||
// on ne demande pas à ParaGlob de faire la transmission, car il ne sait pas ce qu'il transmet
|
||||
// et les infos ne sont pas contigües, le transfert ne sera pas performant
|
||||
void Algori::Globalisation_et_transfert_auxProcCalcul_grandeurs_globales()
|
||||
{ // on s'occupe tout d'abord des grandeurs directement gérées par Algori
|
||||
Vecteur inter(10); // vecteur de passage
|
||||
|
||||
// inter(1) =
|
||||
|
||||
|
||||
|
||||
// ENERGIE_CINETIQUE -> inter(1)
|
||||
// ENERGIE_EXTERNE -> 2
|
||||
// ENERGIE_INTERNE -> 3
|
||||
// PUISSANCE_ACCELERATION);
|
||||
// PUISSANCE_INTERNE);
|
||||
// PUISSANCE_EXTERNE);
|
||||
// PUISSANCE_BILAN);
|
||||
// ENERGIE_ELASTIQUE);
|
||||
// ENERGIE_PLASTIQUE);
|
||||
// ENERGIE_VISQUEUSE);
|
||||
// ENERGIE_BILAN);
|
||||
// QUANTITE_MOUVEMENT);
|
||||
// ENERGIE_PENALISATION);
|
||||
// ENERGIE_FROT_ELAST);
|
||||
// ENERGIE_FROT_PLAST);
|
||||
// ENERGIE_FROT_VISQ);
|
||||
// ENERGIE_VISCO_NUMERIQUE);
|
||||
// ENERGIE_BULK_VISCOSITY);
|
||||
// ENERGIE_HOURGLASS_);
|
||||
// ENERGIE_STABILISATION_MEMB_BIEL);
|
||||
// VOLUME_TOTAL_MATIERE);
|
||||
// MAXPUISSEXT);
|
||||
// MAXPUISSINT);
|
||||
// MAXREACTION);
|
||||
// MAXRESIDUGLOBAL);
|
||||
// MAXdeltaX);
|
||||
// MAXvarDeltaX);
|
||||
// MAXvarDdl);
|
||||
|
||||
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_CINETIQUE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_EXTERNE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_INTERNE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_ACCELERATION);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_INTERNE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_EXTERNE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,PUISSANCE_BILAN);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_ELASTIQUE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_PLASTIQUE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_VISQUEUSE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_BILAN);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,QUANTITE_MOUVEMENT);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_PENALISATION);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_ELAST);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_PLAST);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_FROT_VISQ);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_VISCO_NUMERIQUE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_BULK_VISCOSITY);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_HOURGLASS_);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,ENERGIE_STABILISATION_MEMB_BIEL);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,VOLUME_TOTAL_MATIERE);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXPUISSEXT);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXPUISSINT);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXREACTION);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXRESIDUGLOBAL);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXdeltaX);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXvarDeltaX);
|
||||
// ParaGlob::param->Ajout_grandeur_consultable(&typQ1,MAXvarDdl);
|
||||
|
||||
|
||||
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
2
herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.cc → Algo/AlgoUtilitaires/AlgoInformations.cc
Executable file → Normal file
2
herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.cc → Algo/AlgoUtilitaires/AlgoInformations.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
3
herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.h → Algo/AlgoUtilitaires/AlgoInformations.h
Executable file → Normal file
3
herezh_pp/Algo/AlgoUtilitaires/AlgoInformations.h → Algo/AlgoUtilitaires/AlgoInformations.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -90,6 +90,7 @@ class AlgoInformations : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoInformations* inter = (AlgoInformations*) algo;
|
||||
6
herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc → Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc
Executable file → Normal file
6
herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc → Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -522,7 +522,7 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
|
||||
{
|
||||
// récup du flot
|
||||
ofstream * sort = entreePrinc.Sort_BI();
|
||||
// ofstream * sort = entreePrinc.Sort_BI();
|
||||
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
|
||||
// ecriture: rien pour l'instant
|
||||
// if (cas == 1)
|
||||
|
|
@ -542,7 +542,7 @@ void AlgoUmatAbaqus::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const
|
|||
{if (choix)
|
||||
{// cas d'une lecture normale
|
||||
// récup du flot
|
||||
ifstream * ent = entreePrinc.Ent_BI();
|
||||
// ifstream * ent = entreePrinc.Ent_BI();
|
||||
// pour l'instant on ne lit rien
|
||||
}
|
||||
}
|
||||
2
herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h → Algo/AlgoUtilitaires/AlgoUmatAbaqus.h
Executable file → Normal file
2
herezh_pp/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h → Algo/AlgoUtilitaires/AlgoUmatAbaqus.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
7
herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.cc → Algo/AlgoUtilitaires/AlgoUtils.cc
Executable file → Normal file
7
herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.cc → Algo/AlgoUtilitaires/AlgoUtils.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -91,10 +91,13 @@ void AlgoUtils::Execution(ParaGlob * p,LesMaillages * lesMail
|
|||
// on vérifie que les noeuds sont bien attachés à un élément sinon on met un warning si niveau > 2
|
||||
if (ParaGlob::NiveauImpression() > 2)
|
||||
lesMail->AffichageNoeudNonReferencer();
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// dans le cas d'un contact éventuel on initialise les frontières et la répartition esclave et maître
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
if (lesContacts->Init_contact_pas_effectue())
|
||||
{// initialisation des zones de contacts éventuelles
|
||||
3
herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.h → Algo/AlgoUtilitaires/AlgoUtils.h
Executable file → Normal file
3
herezh_pp/Algo/AlgoUtilitaires/AlgoUtils.h → Algo/AlgoUtilitaires/AlgoUtils.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -94,6 +94,7 @@ class AlgoUtils : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoUtils* inter = (AlgoUtils*) algo;
|
||||
2
herezh_pp/Algo/AlgoUtilitaires/AlgoriRemontErreur.h → Algo/AlgoUtilitaires/AlgoriRemontErreur.h
Executable file → Normal file
2
herezh_pp/Algo/AlgoUtilitaires/AlgoriRemontErreur.h → Algo/AlgoUtilitaires/AlgoriRemontErreur.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Algo/AlgoUtilitaires/RemontErreur.cc → Algo/AlgoUtilitaires/RemontErreur.cc
Executable file → Normal file
2
herezh_pp/Algo/AlgoUtilitaires/RemontErreur.cc → Algo/AlgoUtilitaires/RemontErreur.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -316,7 +316,7 @@ void AlgoriCombine::lecture_Parametres(UtilLecture& entreePrinc)
|
|||
while ( !motCle.SimotCle(entreePrinc.tablcar)) ;
|
||||
// si le mot clé est "PARA_TYPE_DE_CALCUL" cela signifie
|
||||
// qu'il y a un paramètre à lire
|
||||
bool lecture_effective = false;
|
||||
// bool lecture_effective = false;
|
||||
if (strstr(entreePrinc.tablcar,"PARA_TYPE_DE_CALCUL")!=NULL)
|
||||
{ //cas de la définition de paramètres
|
||||
// on signale à Algori qu'il y a eu déjà une lecture de paramètre
|
||||
|
|
@ -846,7 +846,8 @@ void AlgoriCombine::Lecture_algo_interne(const bool avec_typeDeCal
|
|||
string nom_class_methode("AlgoriCombine::Lecture_algo_interne(..."); // pour info lecture
|
||||
// on passe le mot clé de début de liste
|
||||
string mot_cle = "liste_algorithmes_a_combiner_";
|
||||
bool lec_eff = entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
||||
// bool lec_eff = entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
||||
entreePrinc.Lecture_et_verif_mot_cle(nom_class_methode,mot_cle);
|
||||
list < Algori * > list_algori_inter; // une liste de travail pour la lecture
|
||||
// maintenant on va lire chaque algorithme
|
||||
entreePrinc.NouvelleDonnee();
|
||||
|
|
@ -924,6 +925,10 @@ void AlgoriCombine::AutreSortieTempsCPU(ofstream& sort,const int ) const
|
|||
// Temps_CPU_HZpp temps_metrique_K_SM; // lesTempsCpu(14)
|
||||
// Temps_CPU_HZpp temps_chargement; // lesTempsCpu(15)
|
||||
// Temps_CPU_HZpp temps_rech_contact; // lesTempsCpu(16)
|
||||
// cas d'un calcul parallèle: // passage des infos entre process
|
||||
// Temps_CPU_HZpp temps_transfert_court ; // lesTempsCpu(17)
|
||||
// Temps_CPU_HZpp temps_transfert_long ; // lesTempsCpu(19)
|
||||
// Temps_CPU_HZpp temps_attente ; // lesTempsCpu(18)
|
||||
sort << "\n tps_InitAlgo " << lesTsCpu(1);
|
||||
sort << "\n tps_MiseAJourAlgo "<< lesTsCpu(2);
|
||||
sort << "\n tps_CalEquilibre "<< lesTsCpu(3);
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -94,6 +94,7 @@ class AlgoriCombine : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriCombine* inter = (AlgoriCombine*) algo;
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -48,6 +48,15 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// on s'occupe des fonctions nD de pilotage
|
||||
// 1) cas de choix_algo
|
||||
if ((nom_choix_algo.length()) && (choix_algo == NULL))
|
||||
|
|
@ -117,6 +126,10 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
int nb_algo = tab_algo.Taille();
|
||||
for (int i=1;i<=nb_algo;i++)
|
||||
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
#ifdef UTILISATION_MPI
|
||||
// passage de l'équilibrage à ParaGlob
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
#endif
|
||||
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
tab_algo(i)->InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
|
||||
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
|
||||
|
|
@ -170,6 +183,10 @@ void AlgoriCombine::MiseAJourAlgo(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
int nb_algo = tab_algo.Taille();
|
||||
for (int i=1;i<=nb_algo;i++)
|
||||
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
#ifdef UTILISATION_MPI
|
||||
// passage de l'équilibrage à ParaGlob
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
#endif
|
||||
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
tab_algo(i)->MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
|
||||
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
|
||||
|
|
@ -241,6 +258,11 @@ void AlgoriCombine::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// << "\n tab_algo(3)->pa.Deltat()= " << tab_algo(3)->pa.Deltat() << flush;
|
||||
// //--- fin debug
|
||||
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
#ifdef UTILISATION_MPI
|
||||
// passage de l'équilibrage à ParaGlob
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
#endif
|
||||
|
||||
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
|
||||
if (aff_incr)
|
||||
|
|
@ -306,6 +328,11 @@ void AlgoriCombine::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
if ((i >0)&&(i <= nb_algo))
|
||||
{// on met à jour
|
||||
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
#ifdef UTILISATION_MPI
|
||||
// passage de l'équilibrage à ParaGlob
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
#endif
|
||||
|
||||
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
|
||||
if (aff_incr)
|
||||
|
|
@ -374,10 +401,15 @@ void AlgoriCombine::FinCalcul(ParaGlob * paraGlob,LesMaillages * lesMail,LesRefe
|
|||
// // on passe en revue tous les algorithmes et on demande la fin des calculs
|
||||
// non, sinon on a plusieurs dernières sauvegardes !!
|
||||
// donc on ne sauvegarde la fin que via le dernier sous_algo qui a sauvegardé
|
||||
int nb_algo = tab_algo.Taille();
|
||||
// int nb_algo = tab_algo.Taille();
|
||||
// for (int i=1;i<=nb_algo;i++)
|
||||
int i=nb_dernier_algo_qui_a_fait_une_sauvegarde;
|
||||
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
#ifdef UTILISATION_MPI
|
||||
// passage de l'équilibrage à ParaGlob
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
#endif
|
||||
|
||||
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
|
||||
tab_algo(i)->FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
|
||||
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
|
||||
22
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc
Executable file → Normal file
22
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -958,6 +958,15 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_RUNGE_KUTTA); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -1092,6 +1101,10 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// initialisation du compteur d'increments de charge
|
||||
icharge = 0;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -1099,7 +1112,6 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1108,6 +1120,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// definition des elements de contact eventuels
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
};
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -1129,7 +1142,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1170,9 +1183,6 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
}
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -89,6 +89,7 @@ class AlgoriRungeKutta : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriRungeKutta* inter = (AlgoriRungeKutta*) algo;
|
||||
20
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc
Executable file → Normal file
20
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -288,6 +288,9 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
|
||||
// cas du chargement, on verifie egalement la bonne adequation des references
|
||||
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
|
||||
// on indique que l'on ne souhaite pas le temps fin stricte
|
||||
|
|
@ -392,6 +395,10 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
// initialisation du compteur d'increments de charge
|
||||
icharge = 1;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -399,7 +406,6 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -430,7 +436,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -542,10 +548,10 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -866,7 +872,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
Algori::TdtversT();
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -93,6 +93,7 @@ class AlgoriDynaExpli : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriDynaExpli* inter = (AlgoriDynaExpli*) algo;
|
||||
57
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc
Executable file → Normal file
57
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc → Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -43,6 +43,8 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// cas du chargement, on verifie egalement la bonne adequation des references
|
||||
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
|
||||
// on indique que l'on ne souhaite pas le temps fin stricte
|
||||
|
|
@ -148,6 +150,10 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
// au premier passage il y a un traitement spécial: pas d'incrémentation du temps, pas de sauvegarde
|
||||
// in s'agit d'un incrément de mise en place, l'équilibre se faisant à la fin
|
||||
icharge = 0;
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -155,7 +161,6 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -188,7 +193,7 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -304,10 +309,10 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -653,7 +658,7 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
// actualisation des éléments de contact et éventuellement suppression
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
|
|
@ -795,6 +800,15 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -927,6 +941,10 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// in s'agit d'un incrément de mise en place, l'équilibre se faisant à la fin
|
||||
compteur_demarrage = 0; // pas vraiment utile, car sera redéfini dans CalEquilibre
|
||||
icharge = 0;
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -934,7 +952,6 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -943,6 +960,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// definition des elements de contact eventuels
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
};
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -964,7 +982,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1005,9 +1023,6 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
};
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -1119,8 +1134,12 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{
|
||||
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// récup des entités
|
||||
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
|
||||
Assemblage& Ass1 = *Ass1_;
|
||||
// Assemblage& Ass2 = *Ass2_;
|
||||
Assemblage& Ass3 = *Ass3_;
|
||||
|
||||
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
|
||||
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
|
||||
|
|
@ -1135,7 +1154,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
bool arret=false; // booleen pour arrêter indépendamment de la charge
|
||||
bool premier_calcul = true; // utilisé pour le contact
|
||||
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
|
||||
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
// au premier passage il y a un traitement spécial: pas d'incrémentation du temps, pas de sauvegarde
|
||||
compteur_demarrage=0; // donc compteur pour les premiers incréments
|
||||
double max_delta_X=0.; // le maxi du delta X
|
||||
|
|
@ -1149,10 +1168,10 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -1232,7 +1251,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
|
||||
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
|
||||
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
|
||||
lesContacts->Actualisation();
|
||||
lesContacts->Actualisation(0);
|
||||
};
|
||||
|
||||
// dans le cas ou il y a changement de statut il faut remettre à jour
|
||||
|
|
@ -1538,7 +1557,7 @@ void AlgoriDynaExpli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
if (compteur_demarrage != 0) Algori::TdtversT();
|
||||
if ((pa.ContactType())&&(compteur_demarrage > 0))
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -291,6 +291,15 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -422,6 +431,10 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
|
||||
// initialisation du compteur d'increments de charge
|
||||
icharge = 0;
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -429,7 +442,6 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -438,6 +450,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
// definition des elements de contact eventuels
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
};
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -459,7 +472,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -500,9 +513,6 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
|
|||
};
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -610,8 +620,11 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
{
|
||||
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// récup des entités
|
||||
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
|
||||
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
|
||||
Assemblage& Ass3 = *Ass3_;
|
||||
|
||||
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
|
||||
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
|
||||
|
|
@ -628,7 +641,7 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
bool arret=false; // booleen pour arrêter indépendamment de la charge
|
||||
bool premier_calcul = true; // utilisé pour le contact
|
||||
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
|
||||
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
while (((!charge->Fin(icharge))||(icharge == 1))
|
||||
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
|
||||
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
|
|
@ -640,10 +653,10 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -1003,7 +1016,7 @@ void AlgoriDynaExpli_zhai::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
|
|
@ -1084,6 +1097,8 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_ZHAI); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// cas du chargement, on verifie egalement la bonne adequation des references
|
||||
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
|
||||
// on indique que l'on ne souhaite pas le temps fin stricte
|
||||
|
|
@ -1188,6 +1203,10 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
|
|||
// initialisation du compteur d'increments de charge
|
||||
icharge = 1;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -1195,7 +1214,6 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1335,10 +1353,10 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -94,6 +94,7 @@ class AlgoriDynaExpli_zhai : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriDynaExpli_zhai* inter = (AlgoriDynaExpli_zhai*) algo;
|
||||
58
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc
Executable file → Normal file
58
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -280,6 +280,15 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -415,6 +424,10 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
|
||||
// initialisation du compteur d'increments de charge
|
||||
icharge = 0;
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -422,7 +435,6 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -432,6 +444,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// definition des elements de contact eventuels
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
};
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -453,7 +466,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -494,9 +507,6 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
};
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -612,8 +622,11 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
{
|
||||
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// récup des entités
|
||||
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
|
||||
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
|
||||
Assemblage& Ass3 = *Ass3_;
|
||||
|
||||
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
|
||||
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
|
||||
|
|
@ -630,7 +643,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
bool arret=false; // booleen pour arrêter indépendamment de la charge
|
||||
bool premier_calcul = true; // utilisé pour le contact
|
||||
icharge++; // on incrémente le chargement -> donne le num d'incr du prochain incr chargé
|
||||
int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
// int icharge_precedent = icharge; // pour se souvenir du précédent icharge, ne sert que pour l'initialisation
|
||||
while (((!charge->Fin(icharge))||(icharge == 1))
|
||||
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
|
||||
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
|
|
@ -640,10 +653,10 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -713,7 +726,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
|
||||
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
|
||||
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
|
||||
lesContacts->Actualisation();
|
||||
lesContacts->Actualisation(0);
|
||||
};
|
||||
|
||||
// dans le cas ou il y a changement de statut il faut remettre à jour
|
||||
|
|
@ -996,7 +1009,7 @@ void Algori_chung_lee::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
Algori::TdtversT();
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
|
|
@ -1081,6 +1094,8 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_CHUNG_LEE); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// 000 --<C L>-- valeurs figées pour les paramètres de l'algorithme
|
||||
const double betachapeau = 0.5 - (*beta_cl);
|
||||
const double gammaa = 1.5; const double gammachapeau = 1.-gammaa;
|
||||
|
|
@ -1183,10 +1198,13 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
F_int_tdt.Change_taille(nbddl_X); F_ext_tdt.Change_taille(nbddl_X); // forces généralisées int et ext au pas actuel
|
||||
residu_final.Change_taille(nbddl_X); // pour la sauvegarde du résidu pour le post-traitement
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// cas avec contact potentiel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1222,7 +1240,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1342,10 +1360,10 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
// gestion du pas de temps, vérif / pas critique
|
||||
this->Gestion_pas_de_temps(false,lesMail,2); // 2 signifie cas courant
|
||||
bool modif_temps = charge->Avance(); // avancement de la charge et donc du temps courant
|
||||
|
|
@ -1379,7 +1397,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
{lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_tdt);
|
||||
if (pa.ContactType()==4) // dans le cas d'un contact de type 4
|
||||
// on actualise évenuellement la position des noeuds esclaves sur la surface maître
|
||||
lesContacts->Actualisation();
|
||||
lesContacts->Actualisation(0);
|
||||
};
|
||||
|
||||
// mise en place des conditions linéaires
|
||||
|
|
@ -1665,7 +1683,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
Algori::TdtversT();
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -95,6 +95,7 @@ class Algori_chung_lee : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ Algori_chung_lee* inter = (Algori_chung_lee*) algo;
|
||||
138
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc
Executable file → Normal file
138
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -1102,12 +1102,12 @@ void AlgoriRelaxDyna::Info_commande_parametres(UtilLecture& entreePrinc)
|
|||
<< "\n # (ici apres la transition vers l'amortissement visqueux, option_recalcul_mass "
|
||||
<< "\n # initialement a 0, passe à 3) "
|
||||
<< "\n # "
|
||||
<< "\n # typeCalRelaxation= 4 lambda= 0.6 type_calcul_mass= 2 option_recalcul_mass= 0 \ "
|
||||
<< "\n # typeCalRelaxation= 4 lambda= 0.6 type_calcul_mass= 2 option_recalcul_mass= 0 \\ "
|
||||
<< "\n # opt_visqueux_recal_mass= 3 "
|
||||
<< "\n # parametre_calcul_de_la_masse_ casMass_relax= 3 "
|
||||
<< "\n # proportion_cinetique= 0.1 "
|
||||
<< "\n # parametre_recalcul_de_la_masse_ ncycle_calcul= 100 et_pas_recalcul_masse_a_la_transition_"
|
||||
<< "\n # parametre_calcul_de_la_viscosite_ type_calcul_visqu_critique= 2 \ "
|
||||
<< "\n # parametre_calcul_de_la_viscosite_ type_calcul_visqu_critique= 2 \\ "
|
||||
<< "\n # opt_cal_C_critique= 1 f_= 0.9 "
|
||||
<< "\n # mode_debug_= 100 "
|
||||
<< "\n # "
|
||||
|
|
@ -1312,6 +1312,15 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(RELAX_DYNA); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -1452,6 +1461,10 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
compteur_demarrage = -1; // pas vraiment utile, car sera redéfini dans CalEquilibre
|
||||
icharge = 0; // par défaut
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -1459,7 +1472,6 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t); //
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lescontacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1499,7 +1511,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
////--debug
|
||||
|
|
@ -1545,9 +1557,6 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
}
|
||||
};
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -1825,7 +1834,11 @@ Vecteur V_ext(F_int_tdt);
|
|||
// def d'un type quelconque représentatif pour un vecteur force à chaque noeud
|
||||
TypeQuelconque typQ_gene_int(FORCE_GENE_INT,X1,gt);
|
||||
|
||||
// on définit un type générique qui sert pour passer aux noeuds les positions à l'itération 0
|
||||
TypeQuelconque typQ_XI_ITER_0(XI_ITER_0,X1,gt);
|
||||
|
||||
bool arret=false; // booleen pour arrêter indépendamment de la charge
|
||||
bool arret_pilotage=false; // pour arrêt du calcul au niveau du pilotage
|
||||
bool premier_calcul = true; // utilisé pour l'initialisation de l'incrément avec le pas précédent
|
||||
int indicCycleContact = 0; // def d'un indicateur donnant la situation dans le cycle de contact
|
||||
// un booléen pour uniquement gérer le fait que dans la boucle globale on fait le test après le test du while
|
||||
|
|
@ -1838,9 +1851,10 @@ Vecteur V_ext(F_int_tdt);
|
|||
// que si on a eu convergence
|
||||
|| pas_de_convergence_pour_l_instant ||(compteur_demarrage <= 1)
|
||||
)
|
||||
&& (charge->Fin(icharge,true)!=1) // si on a dépassé le temps fin on s'arrête
|
||||
// si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
|
||||
&& ((compteur_demarrage < 1)? (charge->Fin(icharge,false)!=2) : (charge->Fin(icharge,true)!=2))
|
||||
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
&& (charge->Fin(icharge,true)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
|
||||
&& (!pa.EtatSortieEquilibreGlobal())
|
||||
)
|
||||
|
|
@ -1865,6 +1879,19 @@ Vecteur V_ext(F_int_tdt);
|
|||
// bilan: on traite différamment selon que c'est le premier passage le second et les autres
|
||||
bool aff_incr = true; // par défaut, est ensuite renseigné dans le switch qui suit
|
||||
bool change_statut = false; // init des changements de statut
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
// comme on est au début de l'incrément, la géométrie à tdt est identique à celle à t
|
||||
// sauf "au premier incrément", si l'algo est un sous algo d'un algo combiné
|
||||
// et que l'on suit un précédent algo sur un même pas de temps
|
||||
// qui a aboutit à une géométrie à tdt différente de celle de t
|
||||
// du coup cela permet d'utiliser la nouvelle géométrie pour ce premier incrément
|
||||
lesMail->MiseAjourNormaleAuxNoeuds_de_tdt_vers_T();
|
||||
// passage aux noeuds des vecteurs globaux: F_INT, F_EXT
|
||||
Algori::Passage_aux_noeuds_F_int_t_et_F_ext_t(lesMail);
|
||||
|
||||
// qui, pour provoquer un arrêt de la boucle sur les incrément
|
||||
switch (compteur_demarrage)
|
||||
{case -1:
|
||||
{// gestion du pas de temps, mis transitoirement à 0
|
||||
|
|
@ -1882,12 +1909,17 @@ Vecteur V_ext(F_int_tdt);
|
|||
this->Gestion_pas_de_temps(false,lesMail,2); // 2 signifie cas courant
|
||||
if (!indicCycleContact) // modification de la charge et du pas de temps qu'au premier passage
|
||||
// mais pas après un changement de statut
|
||||
{ bool modif_temps = Pilotage_du_temps(charge,arret); // appel du Pilotage
|
||||
{ bool modif_temps = Pilotage_du_temps(charge,arret_pilotage); // appel du Pilotage
|
||||
//-- si le temps a changé il faut de nouveau appeler la gestion du pas de temps
|
||||
// car il y a des grandeurs reliées au pas de temps qui y sont calculé
|
||||
if (modif_temps)
|
||||
this->Gestion_pas_de_temps(true,lesMail,2); // 2 signifie cas courant
|
||||
if (arret) break; // pilotage -> arret du calcul
|
||||
if (arret_pilotage) break; // pilotage -> arret du calcul, on sort du switch
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
{
|
||||
#endif
|
||||
// affichage de l'increment de charge
|
||||
aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
|
||||
if (aff_incr)
|
||||
|
|
@ -1898,6 +1930,11 @@ Vecteur V_ext(F_int_tdt);
|
|||
<< " dt= " << ParaGlob::Variables_de_temps().IncreTempsCourant()
|
||||
<< "\n======================================================================";
|
||||
};
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
}
|
||||
else {aff_incr = false;};
|
||||
#endif
|
||||
// -- initialisation des coordonnees et des ddl a tdt en fonctions des
|
||||
// ddl imposes et de l'increment du chargement: change_statut sera recalculé ensuite
|
||||
lesCondLim->MiseAJour_tdt
|
||||
|
|
@ -1935,7 +1972,11 @@ Vecteur V_ext(F_int_tdt);
|
|||
};
|
||||
}
|
||||
else
|
||||
{ if (arret) break; // pilotage -> arret du calcul
|
||||
{ if (arret_pilotage) break; // pilotage -> arret du calcul
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
cout << "\n============================================================================="
|
||||
<< "\n ....... re-analyse du contact ........ "
|
||||
<< "\nINCREMENT DE CHARGE : " << icharge << " intensite " << charge->IntensiteCharge()
|
||||
|
|
@ -1945,11 +1986,18 @@ Vecteur V_ext(F_int_tdt);
|
|||
};
|
||||
};
|
||||
}; // fin du switch sur compteur_demarrage
|
||||
#ifdef UTILISATION_MPI
|
||||
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
||||
broadcast(*ParaGlob::Monde(), arret_pilotage, 0);
|
||||
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
|
||||
#endif
|
||||
|
||||
if (arret_pilotage) break; // si dans le switch précédent on a un arret de pilotage qui est demandé
|
||||
|
||||
lesLoisDeComp->MiseAJour_umat_nbincr(icharge); // init pour les lois Umat éventuelles
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction de l'existence du contact et du type de modèle de contact
|
||||
// if (pa.ContactType())
|
||||
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
|
||||
// --- récupération (initialisation) des ddl position, vitesse et accélération
|
||||
// récupe X_t initiale
|
||||
|
|
@ -1991,6 +2039,9 @@ Vecteur V_ext(F_int_tdt);
|
|||
// force_recalcul_masse : un indicateur de retour pour la méthode Cinetique_ou_visqueux:
|
||||
bool force_recalcul_masse= false; // par défaut on ne force pas
|
||||
|
||||
// on démarre avec le compteur à 0 et on sauvegarde la position finale à l'itération 0
|
||||
lesMail->Quelconque_glob_vers_local(X1,X_tdt,typQ_XI_ITER_0);
|
||||
|
||||
for (compteur = 0; (compteur<= pa.Iterations())&&(!pa.EtatSortieEquilibreGlobal()); compteur++)
|
||||
//---//\\//\\// début de la boucle sur les itérations d'équilibres //\\//\\//
|
||||
{
|
||||
|
|
@ -2041,6 +2092,11 @@ Vecteur V_ext(F_int_tdt);
|
|||
// affichage ou non de l'itération
|
||||
bool aff_iteration = (pa.freq_affich_iter() > 0) ?
|
||||
(aff_incr && (compteur % pa.freq_affich_iter()==0) &&(compteur!=0)) : false ;
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
if (ParaGlob::Monde()->rank() != 0) aff_iteration=false;
|
||||
#endif
|
||||
|
||||
/* // --- imposition des ddls bloqués
|
||||
// initialisation des coordonnees et des ddl a tdt en fonctions des
|
||||
// ddl imposes et de l'increment du chargement et des conditions linéaires imposées
|
||||
|
|
@ -2166,14 +2222,14 @@ Vecteur V_ext(F_int_tdt);
|
|||
// quand un noeud glisse d'une facette sur une voisine, peut changer la position du noeud
|
||||
// qui est projeté sur la facette dans le cas de l'algorithme cinématique
|
||||
if (((compteur != 0)&&(pa.ContactType()))&&(compteur_demarrage > 0))
|
||||
{ lescontacts->Actualisation(); // en particulier: pour le type 4 on a projection
|
||||
{ lescontacts->Actualisation(0); // en particulier: pour le type 4 on a projection
|
||||
// des noeuds sur les facettes maîtres
|
||||
// mise à jour éventuelle des répercussions du contact sur les noeuds en contact
|
||||
AlgoriRelaxDyna::Repercussion_algo_sur_cinematique(lescontacts,X_tdt,vitesse_tdt);
|
||||
// lesMail->Vect_loc_vers_glob(TEMPS_tdt,X1,X_tdt,X1);
|
||||
// lesMail->Vect_loc_vers_glob(TEMPS_tdt,V1,vitesse_tdt,V1);
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
};
|
||||
// -+-+ sinon l'actualisation du contact s'effectue à la fin de l'itération (un peu plus loin)
|
||||
|
||||
|
|
@ -2309,8 +2365,14 @@ Vecteur V_ext(F_int_tdt);
|
|||
InfoIncrementReac(lesMail,inReaction,maxReaction,Ass3.Nb_cas_assemb());
|
||||
};
|
||||
|
||||
bool arretResidu = false; // pour gérer le cas particulier ou on veut un arrêt et sur le résidu et sur le déplacement
|
||||
bool demande_de_break=false; // pour gestion du break en tenant compte ou non du MPI
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la convergence
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
{
|
||||
#endif
|
||||
// examen de la convergence si nécessaire, utilisant le résidu
|
||||
bool arretResidu = false; // pour gérer le cas particulier ou on veut un arrêt et sur le résidu et sur le déplacement
|
||||
if (ArretEquilibreStatique() && (compteur>1) && (compteur_demarrage != 0) )// cas d'une convergence en utilisant le résidu
|
||||
{ double toto=0.; int itera = 0; // valeur par defaut pour ne pas se mettre dans un cas itératif de type algo de Newton
|
||||
bool arret_demande = false; // normalement n'intervient pas ici, car il n'y a pas de prise en compte d'iteration
|
||||
|
|
@ -2329,12 +2391,26 @@ Vecteur V_ext(F_int_tdt);
|
|||
)
|
||||
)
|
||||
{ arretResidu=true;} // cas relaxation avec amortissement cinétique
|
||||
else {break;}; // cas normal,
|
||||
else {demande_de_break=true;}//break;}; // cas normal,
|
||||
};
|
||||
};
|
||||
};
|
||||
#ifdef UTILISATION_MPI
|
||||
};
|
||||
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
||||
broadcast(*ParaGlob::Monde(), arretResidu, 0);
|
||||
broadcast(*ParaGlob::Monde(), arret, 0);
|
||||
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
|
||||
#endif
|
||||
if (demande_de_break)
|
||||
break;
|
||||
|
||||
// 4 --<ARD>-- calcul des nouvelles accélérations
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 fait la résolution globale
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
{
|
||||
#endif
|
||||
// resolution simple (fonction du type de matrice)
|
||||
// ou non suivant modif_repere
|
||||
tempsResolSystemLineaire.Mise_en_route_du_comptage(); // temps cpu
|
||||
|
|
@ -2355,6 +2431,17 @@ Vecteur V_ext(F_int_tdt);
|
|||
// retour des accélération dans les reperes generaux, dans le cas où ils ont ete modifie
|
||||
// par des conditions linéaires
|
||||
lesCondLim->RepInitiaux( acceleration_tdt,Ass3.Nb_cas_assemb());
|
||||
#ifdef UTILISATION_MPI
|
||||
}
|
||||
else // s'il s'agit d'un process de calcul élémentaire
|
||||
{sol = &vglobaal; // il faut affecter sol pour récupérer ensuite la solution
|
||||
};
|
||||
// le process 0 transmet aux autres process le vecteur résultat
|
||||
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
|
||||
sol->Broadcast(0);
|
||||
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
|
||||
#endif
|
||||
|
||||
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
|
||||
lesCondLim->EffMarque();
|
||||
if (pa.ContactType()) lescontacts->EffMarque();
|
||||
|
|
@ -2374,7 +2461,7 @@ Vecteur V_ext(F_int_tdt);
|
|||
// dans le cas ou la recherche de nouveaux contacts est effectuée à chaque itération
|
||||
if (((type_activation_contact== 1) && (pa.ContactType()))&&(compteur_demarrage > 0))
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lescontacts->Actualisation(); // si on n'a plus de projection
|
||||
lescontacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lescontacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
|
|
@ -2451,6 +2538,13 @@ Vecteur V_ext(F_int_tdt);
|
|||
};
|
||||
|
||||
// gestion de la fin des itérations
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 a fait la résolution globale
|
||||
// il gère seul également la convergence, mais il doit tenir au courant les autres process
|
||||
Algori::Passage_indicConvergenceAuxProcCalcul();
|
||||
// ce qui permet le déroulement correct de la suite pour tous les process
|
||||
#endif
|
||||
|
||||
if ( ((compteur_demarrage > 0) && (!Pilotage_fin_iteration_implicite(compteur))))
|
||||
{ // cas d'une non convergence
|
||||
pas_de_convergence_pour_l_instant = 1;
|
||||
|
|
@ -2471,7 +2565,7 @@ Vecteur V_ext(F_int_tdt);
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -2494,9 +2588,9 @@ Vecteur V_ext(F_int_tdt);
|
|||
cout << " \n ... convergence en " << compteur << " iterations "<< endl ;
|
||||
// traitement du contact dans le cas où son activation n'a pas été faite à chaque itération
|
||||
if ((pa.ContactType()) && (type_activation_contact != 1))
|
||||
{ lescontacts->Actualisation(); // actualisation du contact en fonction du dernier incrément
|
||||
{ lescontacts->Actualisation(0); // actualisation du contact en fonction du dernier incrément
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
// mato = Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
// Mise_a_jour_Choix_matriciel_contact(mato,Ass.Nb_cas_assemb(),lescontacts);
|
||||
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
|
||||
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
|
||||
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage
|
||||
|
|
@ -2549,7 +2643,7 @@ Vecteur V_ext(F_int_tdt);
|
|||
// cas du calcul des énergies, passage des grandeurs de tdt à t
|
||||
if (compteur_demarrage != -1) Algori::TdtversT();
|
||||
// actualisation des éléments de contact et éventuellement suppression
|
||||
if (pa.ContactType()) lescontacts->Actualisation(); // des éléments qui ne sont plus en contact
|
||||
if (pa.ContactType()) lescontacts->Actualisation(0); // des éléments qui ne sont plus en contact
|
||||
if (compteur_demarrage != -1)
|
||||
{// on valide l'activité des conditions limites et condition linéaires
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
30
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc
Executable file → Normal file
30
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -869,6 +869,15 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -994,6 +1003,10 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
|
||||
// initialisation du compteur d'increments de charge
|
||||
icharge = 0;
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -1001,7 +1014,6 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1033,7 +1045,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1075,9 +1087,6 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
}
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -1188,8 +1197,11 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{
|
||||
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// récup des entités
|
||||
Assemblage& Ass1 = *Ass1_;Assemblage& Ass2 = *Ass2_;Assemblage& Ass3 = *Ass3_;
|
||||
Assemblage& Ass1 = *Ass1_;//Assemblage& Ass2 = *Ass2_;
|
||||
Assemblage& Ass3 = *Ass3_;
|
||||
|
||||
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
|
||||
int validation_calcul = 1; // init : par défaut la validation est effective si le calcul converge
|
||||
|
|
@ -1217,7 +1229,7 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -1619,7 +1631,7 @@ void AlgoriTchamwa::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
Algori::TdtversT();
|
||||
if (pa.ContactType())
|
||||
{ // actualisation des éléments de contact et éventuellement inactivation d'éléments
|
||||
lesContacts->Actualisation(); // si on n'a plus de projection
|
||||
lesContacts->Actualisation(0); // si on n'a plus de projection
|
||||
// on inactive les éléments de contact qui se relache: testé soit via la réaction
|
||||
lesContacts->RelachementNoeudcolle(); // ou via la sortie d'une zone d'accostage (dépend de l'algo)
|
||||
};
|
||||
7
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h
Executable file → Normal file
7
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -91,16 +91,19 @@ class AlgoriTchamwa : public Algori
|
|||
// constructeur de copie à partie d'une instance indifférenciée
|
||||
Algori * New_idem(const Algori* algo) const
|
||||
{// on vérifie qu'il s'agit bien d'une instance
|
||||
Algori * retour = NULL;
|
||||
if (algo->TypeDeCalcul() != DYNA_EXP_TCHAMWA)
|
||||
{ cout << "\n *** erreur lors de la creation par copie d'un algo DYNA_EXP_TCHAMWA "
|
||||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
retour = NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriTchamwa* inter = (AlgoriTchamwa*) algo;
|
||||
return ((Algori *) new AlgoriTchamwa(*inter));
|
||||
retour = ((Algori *) new AlgoriTchamwa(*inter));
|
||||
};
|
||||
return retour;
|
||||
};
|
||||
|
||||
// DESTRUCTEUR :
|
||||
14
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc
Executable file → Normal file
14
herezh_pp/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc → Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -40,6 +40,8 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// cas du chargement, on verifie egalement la bonne adequation des references
|
||||
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
|
||||
// on indique que l'on ne souhaite pas le temps fin stricte
|
||||
|
|
@ -181,7 +183,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -294,7 +296,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -626,6 +628,8 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{ // INITIALISATION globale
|
||||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_TCHAMWA); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
// cas du chargement, on verifie egalement la bonne adequation des references
|
||||
charge->Initialise(lesMail,lesRef,pa,*lesCourbes1D,*lesFonctionsnD);
|
||||
// on indique que l'on ne souhaite pas le temps fin stricte
|
||||
|
|
@ -762,7 +766,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -880,7 +884,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
2
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc
Executable file → Normal file
2
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -92,6 +92,7 @@ class AlgoriNewmark : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriNewmark* inter = (AlgoriNewmark*) algo;
|
||||
38
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc
Executable file → Normal file
38
herezh_pp/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc → Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -47,6 +47,15 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_IMP); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -211,6 +220,10 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// boucle sur les increments de charge
|
||||
icharge = 0; // init
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -220,7 +233,6 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
bool premier_calcul = true;
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -229,7 +241,8 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// definition des elements de contact eventuels
|
||||
bool nevez_contact = lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nevez_contact,lesCondLim
|
||||
,lesRef,tab_mato,Ass1.Nb_cas_assemb(),lesContacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -263,7 +276,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on réinitialise des ddl avec les conditions initiales because on vient de tout libérer les ddl
|
||||
// or dans Initial, il y a des inits à faire au niveau des statuts
|
||||
// lesCondLim->Initial(lesMail,lesRef,lesCourbes1D,lesFonctionsnD,true,cas_combi_ddl);
|
||||
|
|
@ -286,9 +299,10 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
if (lesMail->NbEsclave() != 0)
|
||||
{// on met à jour la boite d'encombrement compte tenue des nouvelles coordonnées
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
bool nevez_contact = lesContacts->Actualisation();
|
||||
bool nevez_contact = lesContacts->Actualisation(0);
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nevez_contact,lesCondLim
|
||||
,lesRef,tab_mato,Ass1.Nb_cas_assemb(),lesContacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -332,9 +346,6 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
};
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -787,10 +798,11 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{ int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool a_changer = false; // init
|
||||
if (compteur != 0)
|
||||
a_changer = lescontacts->Actualisation();
|
||||
a_changer = lescontacts->Actualisation(1);
|
||||
// mise à jour éventuelle des matrices de raideur en fonction du contact
|
||||
if (a_changer)
|
||||
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
{//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
|
||||
,tab_mato,Ass1.Nb_cas_assemb(),lescontacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -1129,7 +1141,7 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1153,7 +1165,7 @@ void AlgoriNewmark::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{ cout << "\n --- |max_var_DeltaDdl|= "<< max_var_delta_X
|
||||
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
|
||||
if (pa.ContactType())
|
||||
{ bool nevez_contact = lescontacts->Actualisation(); // actualisation du contact en fonction du dernier incrément
|
||||
{ bool nevez_contact = lescontacts->Actualisation(0); // actualisation du contact en fonction du dernier incrément
|
||||
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
|
||||
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
|
||||
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -390,6 +390,10 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
// initialisation du compteur d'increments de charge
|
||||
icharge = 1;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -397,7 +401,6 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -427,7 +430,7 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -538,10 +541,10 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
|
|||
double maxPuissInt; // maxi de la puissance des efforts internes
|
||||
double maxReaction; // maxi des reactions
|
||||
int inReaction = 0; // pointeur d'assemblage pour le maxi de reaction
|
||||
int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// int inSol =0 ; // pointeur d'assemblage du maxi de variation de ddl
|
||||
// double maxDeltaDdl=0; // // maxi de variation de ddl
|
||||
// initialisation de la variable puissance_précédente d'une itération à l'autre
|
||||
double puis_precedente = 0.;
|
||||
// double puis_precedente = 0.;
|
||||
|
||||
// mise à jour du calcul éventuel des normales aux noeuds -> mise à jour des normales à t
|
||||
// mais ici, on calcule les normales à tdt, et on transfert à t
|
||||
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -90,6 +90,7 @@ class AlgoristatExpli : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoristatExpli* inter = (AlgoristatExpli*) algo;
|
||||
|
|
@ -240,7 +241,7 @@ class AlgoristatExpli : public Algori
|
|||
// écoute et prise en compte d'une commande interactive
|
||||
// ramène true tant qu'il y a des commandes en cours
|
||||
///**** inexploitable pour l'instant
|
||||
bool ActionInteractiveAlgo(){};
|
||||
bool ActionInteractiveAlgo(){return false;};
|
||||
|
||||
|
||||
|
||||
13
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc
Executable file → Normal file
13
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -162,6 +162,10 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// boucle sur les increments de charge
|
||||
icharge = 1;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -169,7 +173,6 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -194,7 +197,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -251,7 +254,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// de calculer meme si l'utilisateur indique un increment de charge supÈrieur
|
||||
// au temps final
|
||||
bool arret=false; // pour arrÍt du calcul au niveau du pilotage
|
||||
while ((!charge->Fin(icharge))||(icharge == 1)
|
||||
while (((!charge->Fin(icharge))||(icharge == 1))
|
||||
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
|
||||
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
|
||||
|
|
@ -308,7 +311,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
else
|
||||
lesLoisDeComp->Loi_simplifie(false);
|
||||
// bool sur_raideur = false; // pour l'instant pas de prise en compte sur la raideur
|
||||
bool sur_raideur = true; // essai
|
||||
// bool sur_raideur = true; // essai
|
||||
// mise en place du chargement impose, c-a-d calcul de la puissance externe
|
||||
// si pb on sort de la boucle
|
||||
if (!(charge->ChargeSMembreRaideur_Im_mecaSolid
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h → Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h → Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -91,6 +91,7 @@ class AlgoriFlambLineaire : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriFlambLineaire* inter = (AlgoriFlambLineaire*) algo;
|
||||
6
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc
Executable file → Normal file
6
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -269,10 +269,6 @@ void AlgoriNonDyna::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
,divStock,charge,lesCondLim,lesContacts,resultats );
|
||||
};
|
||||
|
||||
//---- fonction obsolete >> a virer !! ---------------------
|
||||
// Calcul_Equilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesLoisDeComp
|
||||
// ,divStock,charge,lesCondLim,lesContacts,resultats );
|
||||
//---- fin fonction obsolete >> a virer !! -----------------
|
||||
|
||||
};// fin du cas sans commandes interactives
|
||||
// ensuite on teste en fonction des calculs complémentaires
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -91,6 +91,7 @@ class AlgoriNonDyna : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoriNonDyna* inter = (AlgoriNonDyna*) algo;
|
||||
185
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc
Executable file → Normal file
185
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc → Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -48,6 +48,26 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(NON_DYNA); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
////------- debug
|
||||
//cout << "\n debug AlgoriNonDyna::InitAlgorithme ";
|
||||
//lesMail->Noeud_LesMaille(1,120).Affiche(9);
|
||||
//cout << endl;
|
||||
////-------- fin debug
|
||||
|
||||
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -218,22 +238,24 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// initi boucle sur les increments de charge
|
||||
icharge = 0;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
// par exemple il faut initialiser les frontières et la répartition esclave et maître
|
||||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
{ lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
// verification qu'il n'y a pas de contact avant le premier increment de charge
|
||||
lesContacts->Verification();
|
||||
// definition des elements de contact eventuels
|
||||
// et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
// // definition des elements de contact eventuels
|
||||
// // et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
|
||||
// lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
if (pa.ContactType() == 4) // cas particulier du type 4 de contact où on utilise les forces internes
|
||||
{// def d'un type générique, utilisé pour le transfert des forces internes, vers les conteneurs noeuds
|
||||
Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
|
|
@ -247,11 +269,14 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// double diam_mini = lesMail->Min_dist2Noeud_des_elements(TEMPS_0);
|
||||
// lesContacts->DefElemCont(2. * diam_mini);
|
||||
try {
|
||||
// definition des elements de contact eventuels
|
||||
// et imposition éventuel de certaines des conditions de contact (dépend du modèle de contact)
|
||||
bool nevez_contact = lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool premier_calcul = true;
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nevez_contact,lesCondLim
|
||||
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -272,6 +297,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
};
|
||||
|
||||
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -311,8 +337,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -334,11 +359,15 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
};
|
||||
// sinon ok, et on met à jour la boite d'encombrement compte tenue des nouvelles coordonnées
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
bool nevez_contact = lesContacts->Actualisation();
|
||||
bool nevez_contact = lesContacts->Actualisation(0);
|
||||
// *** test
|
||||
bool nevez_bis_contact = lesContacts->Nouveau(0.);
|
||||
nevez_contact = (nevez_contact || nevez_bis_contact); //double dep_max)
|
||||
int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool premier_calcul = true;
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nevez_contact,lesCondLim
|
||||
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -382,9 +411,6 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
};
|
||||
};
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// init de var glob
|
||||
Transfert_ParaGlob_COMPTEUR_INCREMENT_CHARGE_ALGO_GLOBAL(icharge);
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
|
@ -552,6 +578,10 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// mais pas après un changement de statut
|
||||
{ Pilotage_du_temps(charge,arret_pilotage); // appel du Pilotage
|
||||
if (arret_pilotage) break; // pilotage -> arret du calcul
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (aff_incr)
|
||||
{cout << "\n======================================================================"
|
||||
<< "\nINCREMENT DE CHARGE : " << icharge
|
||||
|
|
@ -593,11 +623,13 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
else
|
||||
{ // on supprime les éléments inactifs testés à l'incr prec dans Actualisation()
|
||||
a_changer = lescontacts->SuppressionDefinitiveElemInactif();
|
||||
a_changer = a_changer || lescontacts->Nouveau(max_delta_X);
|
||||
bool a_changer_nouveau = lescontacts->Nouveau(max_delta_X);
|
||||
a_changer = a_changer || a_changer_nouveau;
|
||||
};
|
||||
int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
if (premier_calcul || a_changer)
|
||||
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
{//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
|
||||
,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -607,7 +639,11 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
}
|
||||
else
|
||||
{if (arret_pilotage) break; // pilotage -> arret du calcul
|
||||
cout << "\n============================================================================="
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la sortie
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
cout << "\n============================================================================="
|
||||
<< "\n ....... re-analyse du contact ........ "
|
||||
<< "\nINCREMENT DE CHARGE : " << icharge << " intensite " << charge->IntensiteCharge()
|
||||
<< " t= " << charge->Temps_courant()
|
||||
|
|
@ -693,10 +729,11 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// qui est projeté sur la facette dans le cas de l'algorithme cinématique
|
||||
if (pa.ContactType())
|
||||
{ int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool a_changer = lescontacts->Actualisation();
|
||||
bool a_changer = lescontacts->Actualisation(1);
|
||||
// mise à jour éventuelle des matrices de raideur en fonction du contact
|
||||
if (a_changer)
|
||||
{bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
{//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,a_changer,lesCondLim,lesRef
|
||||
,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -879,7 +916,12 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
// calcul de la variation de ddl / delta t
|
||||
// delta_X = X_tdt; delta_X -= X_t; // X_tdt - X_t
|
||||
Algori::Cal_Transfert_delta_et_var_X(max_delta_X,max_var_delta_X);
|
||||
if (permet_affichage > 3)
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
|
||||
if ((ParaGlob::Monde()->rank() == 0)&&(permet_affichage > 3))
|
||||
#else
|
||||
if (permet_affichage > 3)
|
||||
#endif
|
||||
{ cout << "\n --- |max_var_DeltaDdl|= "<< max_var_delta_X
|
||||
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
|
||||
// ---dans le cas du mode debug on sort éventuellement les infos au fil du calcul (un peu bricolé)
|
||||
|
|
@ -907,6 +949,12 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
|
||||
decol = false; // pour debugger
|
||||
|
||||
bool arret_iteration = false;
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 s'occupe de la convergence
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
{
|
||||
#endif
|
||||
if (Convergence(aff_iteration,last_var_ddl_max,vglobaal,maxPuissExt,maxPuissInt,maxReaction,compteur,arret_convergence)
|
||||
&& !decol)
|
||||
{ // on sort de la boucle des itérations sauf si l'on est en loi simplifiée
|
||||
|
|
@ -915,10 +963,19 @@ decol = false; // pour debugger
|
|||
{ lesLoisDeComp->Loi_simplifie(false);}
|
||||
else
|
||||
// cas normal,
|
||||
{break;};
|
||||
{arret_iteration = true; }; //break;};
|
||||
}
|
||||
else if (arret_convergence)
|
||||
{break;} // cas ou la méthode Convergence() demande l'arret
|
||||
{arret_iteration = true; }; //break;} // cas ou la méthode Convergence() demande l'arret
|
||||
#ifdef UTILISATION_MPI
|
||||
};
|
||||
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
||||
broadcast(*ParaGlob::Monde(), arret_iteration, 0);
|
||||
temps_transfert_court.Arret_du_comptage(); // fin comptage cpu
|
||||
#endif
|
||||
if (arret_iteration)
|
||||
break;
|
||||
|
||||
// sinon on continue
|
||||
// pour le pilotage ou pour l'accélération de convergence, sauvegarde du résidu
|
||||
if (pa.Line_search() || (acceleration_convergence))
|
||||
|
|
@ -929,6 +986,11 @@ decol = false; // pour debugger
|
|||
bool erreur_resolution_syst_lineaire = false; // init
|
||||
int nb_matrice_secondaire = tab_mato.Taille(); // = 1 par défaut, mais on peut en avoir d'autre
|
||||
int niveau_substitution = 1; // par défaut on utilise la matrice de raideur matglob = tab_mato(1)
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 fait la résolution globale
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
{
|
||||
#endif
|
||||
while (niveau_substitution <= nb_matrice_secondaire)
|
||||
{ // on sauvegarde éventuellement le second membre
|
||||
if (nb_matrice_secondaire > 1) // cela veut dire que l'on est suceptible de faire plusieurs boucles
|
||||
|
|
@ -984,11 +1046,6 @@ decol = false; // pour debugger
|
|||
};
|
||||
tempsResolSystemLineaire.Arret_du_comptage(); // temps cpu
|
||||
|
||||
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
|
||||
lesCondLim->EffMarque();
|
||||
if ((pa.ContactType()==1) || (pa.ContactType()==3))
|
||||
lescontacts->EffMarque();
|
||||
|
||||
// cas où on a eu au final une erreur de résolution
|
||||
if (erreur_resolution_syst_lineaire)
|
||||
{Change_PhaseDeConvergence(-9); // on signale une divergence due à la résolution
|
||||
|
|
@ -1016,6 +1073,44 @@ decol = false; // pour debugger
|
|||
if ((aff_iteration)&&(ParaGlob::NiveauImpression() > 1))
|
||||
InfoIncrementDdl(lesMail,inSol,maxDeltatDdl_signe,Ass.Nb_cas_assemb());
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
}
|
||||
else // s'il s'agit d'un process de calcul élémentaire
|
||||
{sol = &vglobaal; // il faut affecter sol pour récupérer ensuite la solution
|
||||
};
|
||||
// le process 0 transmet aux autres process le vecteur résultat
|
||||
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
|
||||
|
||||
//// essai pour remplacer broadcast
|
||||
// int nb_process = ParaGlob::Monde()->size();
|
||||
// mpi::request reqs1;
|
||||
// if (ParaGlob::Monde()->rank() == 0)
|
||||
// // NB: le process 0 c'est le main
|
||||
// {for (int i=1;i<nb_process;i++) // < absolu, donc le max c'est nb_process-1
|
||||
// {reqs1 = sol->Ienvoi_MPI(i, 38);}
|
||||
// }
|
||||
// else
|
||||
// {reqs1 = sol->Irecup_MPI(0,38);};
|
||||
//// ParaGlob::Monde()->barrier();
|
||||
// reqs1.wait();
|
||||
|
||||
// mpi::request Ienvoi_MPI(int dest, int tag) const
|
||||
// {return ParaGlob::Monde()->isend(dest,tag,v,taille);};
|
||||
// mpi::request Irecup_MPI(int source, int tag) const
|
||||
|
||||
sol->Broadcast(0);
|
||||
// broadcast(*ParaGlob::Monde(), *sol, 0);
|
||||
// synchronisation ici de tous les process (à supprimer par la suite car n'est
|
||||
// pas nécessaire pour le déroulementa priori ?? )
|
||||
// ParaGlob::Monde()->barrier();
|
||||
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
|
||||
#endif
|
||||
|
||||
// effacement du marquage de ddl bloque du au conditions lineaire imposée par l'entrée
|
||||
lesCondLim->EffMarque();
|
||||
if ((pa.ContactType()==1) || (pa.ContactType()==3))
|
||||
lescontacts->EffMarque();
|
||||
|
||||
// suite du pilotage
|
||||
// ------------------------------------------------------------
|
||||
// |on regarde s'il faut utiliser l'algorithme de line search |
|
||||
|
|
@ -1070,7 +1165,15 @@ decol = false; // pour debugger
|
|||
};
|
||||
|
||||
if ((pa.ContactType()==1) || (pa.ContactType()==3)) lescontacts->EffMarque();
|
||||
// gestion de la fin des itérations
|
||||
|
||||
// === gestion de la fin des itérations ===
|
||||
#ifdef UTILISATION_MPI
|
||||
// seule le process 0 a fait la résolution globale
|
||||
// il gère seul également la convergence, mais il doit tenir au courant les autres process
|
||||
Algori::Passage_indicConvergenceAuxProcCalcul();
|
||||
// ce qui permet le déroulement correct de la suite pour tous les process
|
||||
#endif
|
||||
|
||||
if ((!Pilotage_fin_iteration_implicite(compteur))||(pa.EtatSortieEquilibreGlobal()))
|
||||
// if ((!Pilotage_fin_iteration_implicite(compteur))
|
||||
// && (!pa.EtatSortieEtatActuelDansBI()))
|
||||
|
|
@ -1097,7 +1200,7 @@ decol = false; // pour debugger
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1118,14 +1221,15 @@ decol = false; // pour debugger
|
|||
<< " , |max_deltaDdl|= " << max_delta_X << flush;};
|
||||
if (pa.ContactType())
|
||||
{ // actualisation du contact en fonction du dernier incrément
|
||||
bool nevez_contact = lescontacts->Actualisation();
|
||||
bool nevez_contact = lescontacts->Actualisation(0);
|
||||
// réexamen du contact pour voir s'il n'y a pas de nouveau element de contact
|
||||
// en fait on fera au plus deux passages supplémentaire, sinon la boucle peut être infini,
|
||||
// à la fin du second passage, on regarde s'il y a décollement, si oui on relâche et on refait un passage
|
||||
// sinon on valide
|
||||
//I)--------------
|
||||
if (indicCycleContact == 0 )
|
||||
{ nevez_contact = nevez_contact || lescontacts->Nouveau(lesMail->Max_var_dep_t_a_tdt());
|
||||
{ bool nouveau_contact = lescontacts->Nouveau(lesMail->Max_var_dep_t_a_tdt());
|
||||
nevez_contact = nevez_contact || nouveau_contact;
|
||||
if (nevez_contact)
|
||||
{indicCycleContact=1;} // on a de nouveau contact on refait le deuxième cycle
|
||||
else
|
||||
|
|
@ -1150,7 +1254,8 @@ decol = false; // pour debugger
|
|||
)
|
||||
{int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool nouveau = (nevez_contact || relachement_contact);
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nouveau,lesCondLim
|
||||
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -1662,6 +1767,10 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
// boucle sur les increments de charge
|
||||
icharge = 1;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -1669,7 +1778,6 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -1683,7 +1791,8 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
int niveau_substitution = 0; // on intervient sur toutes les matrices
|
||||
bool premier_calcul = true;
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
bool changement_sur_matrice = Gestion_stockage_et_renumerotation_avec_contact
|
||||
//bool changement_sur_matrice =
|
||||
Gestion_stockage_et_renumerotation_avec_contact
|
||||
(premier_calcul,lesMail,nevez_contact,lesCondLim
|
||||
,lesRef,tab_mato,Ass.Nb_cas_assemb(),lesContacts,niveau_substitution);
|
||||
matglob=tab_mato(1);
|
||||
|
|
@ -1718,7 +1827,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -1765,7 +1874,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
// de calculer meme si l'utilisateur indique un increment de charge supérieur
|
||||
// au temps final
|
||||
bool arret_pilotage=false; // pour arrêt du calcul au niveau du pilotage
|
||||
while ((!charge->Fin(icharge))||(icharge == 1)
|
||||
while (((!charge->Fin(icharge))||(icharge == 1))
|
||||
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
|
||||
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
|
||||
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
|
||||
|
|
@ -1873,7 +1982,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
|
|||
(aff_incr && (compteur % pa.freq_affich_iter()==0) &&(compteur!=0)) : false ;
|
||||
lesLoisDeComp->MiseAJour_umat_nbiter(compteur); // init pour les lois Umat éventuelles
|
||||
// bool sur_raideur = false; // pour l'instant pas de prise en compte sur la raideur
|
||||
bool sur_raideur = true; // essai
|
||||
// bool sur_raideur = true; // essai
|
||||
// mise en place du chargement impose, c-a-d calcul de la puissance externe
|
||||
// si pb on sort de la boucle
|
||||
if (!(charge->ChargeSMembreRaideur_Im_mecaSolid
|
||||
9
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc → Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc
Executable file → Normal file
9
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc → Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -255,6 +255,10 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
//--** // un premier increment pour demmarer le processus
|
||||
//--** charge->Avance(); // premier increment de charge ????????? différent des autres algos
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -262,7 +266,6 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lescontacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -478,7 +481,7 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
|
|||
// actualisation des conditions de contact qui peuvent changer
|
||||
// la largeur de bande, quand un noeud glisse d'une facette sur une voisine
|
||||
if (compteur != 0)
|
||||
{ lescontacts->Actualisation();
|
||||
{ lescontacts->Actualisation(1);
|
||||
// mise à jour éventuelle de la matrice de raideur en fonction du contact
|
||||
Mise_a_jour_Choix_matriciel_contact(tab_mato,Ass.Nb_cas_assemb(),lescontacts,niveau_substitution);
|
||||
mato=tab_mato(1);
|
||||
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h → Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h → Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -88,6 +88,7 @@ class ImpliNonDynaCont : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ ImpliNonDynaCont* inter = (ImpliNonDynaCont*) algo;
|
||||
36
herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc → Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc
Executable file → Normal file
36
herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc → Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc
Executable file → Normal file
|
|
@ -7,7 +7,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -320,7 +320,7 @@ void AlgoBonelli::Gestion_pas_de_temps(LesMaillages * lesMail,int cas,int )
|
|||
case 1 :
|
||||
{ // --<DG>-- récup du pas de temps, proposé par l'utilisateur
|
||||
delta_t = pa.Deltat(); double delta_t_old = delta_t;
|
||||
double delta_tSauve = delta_t; // sauvegarde de la situation actuelle
|
||||
// double delta_tSauve = delta_t; // sauvegarde de la situation actuelle
|
||||
// --<DG>-- on calcul le pas de temps minimal pour cela on utilise
|
||||
// les caractéristiques dynamiques d'une biellette de longueur
|
||||
// valant le minimum d'un coté d'arrête
|
||||
|
|
@ -647,6 +647,15 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_BONELLI); // transfert info
|
||||
|
||||
#ifdef UTILISATION_MPI
|
||||
// calcul de l'équilibrage initiale par le cpu 0
|
||||
if (distribution_CPU_algo.Tableau_element_CPU_en_cours()->Taille() == 0 )
|
||||
{distribution_CPU_algo.Calcul_Equilibrage_initiale(lesMail);
|
||||
distribution_CPU_algo.Passage_Equilibrage_aux_CPU();
|
||||
paraGlob->Init_tableau (distribution_CPU_algo.Tableau_element_CPU_en_cours());
|
||||
};
|
||||
#endif
|
||||
|
||||
// avant toute chose, au cas où l'algo interviendrait après un autre algo
|
||||
// on inactive tous les ddl existants
|
||||
lesMail->Inactive_ddl();
|
||||
|
|
@ -780,6 +789,10 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// initialisation du compteur d'increments de charge
|
||||
icharge = 0;
|
||||
|
||||
// definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
lesMail->CreeElemFront();
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
// --- init du contact ---
|
||||
// doit-être avant la lecture d'un restart, car il y a une initialisation de conteneurs qui est faites
|
||||
// qui ensuite est utilisée en restart
|
||||
|
|
@ -787,7 +800,8 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// pour préparer la lecture de restart éventuel
|
||||
if (lesMail->NbEsclave() != 0)
|
||||
{ // definition des elements de frontiere, ces elements sont utilises pour le contact
|
||||
int cal_front = lesMail->CreeElemFront();
|
||||
// int cal_front =
|
||||
lesMail->CreeElemFront();
|
||||
lesMail->Mise_a_jour_boite_encombrement_elem_front(TEMPS_t);
|
||||
// initialisation des zones de contacts éventuelles
|
||||
lesContacts->Init_contact(*lesMail,*lesRef,lesFonctionsnD);
|
||||
|
|
@ -796,6 +810,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
// definition des elements de contact eventuels
|
||||
lesContacts->DefElemCont(0.); // au début le déplacement des noeuds est nul
|
||||
};
|
||||
|
||||
//--cas de restart et/ou de sauvegarde------------
|
||||
// tout d'abord récup du restart si nécessaire
|
||||
// dans le cas ou un incrément différent de 0 est demandé -> seconde lecture à l'incrément
|
||||
|
|
@ -817,7 +832,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
lesMail->ChangeStatut(cas_combi_ddl,LIBRE);
|
||||
// dans le cas d'un calcul axisymétrique on bloque le ddl 3
|
||||
if (ParaGlob::AxiSymetrie())
|
||||
lesMail->Inactive_un_type_ddl_particulier(X3);
|
||||
lesMail->Inactive_un_ddl_particulier(X3);
|
||||
// on valide l'activité des conditions limites et condition linéaires, pour le temps initial
|
||||
// en conformité avec les conditions lues (qui peuvent éventuellement changé / aux calcul qui a donné le .BI)
|
||||
lesCondLim->Validation_blocage (lesRef,charge->Temps_courant());
|
||||
|
|
@ -858,9 +873,6 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
|
|||
}
|
||||
//--fin cas de restart et/ou de sauvegarde--------
|
||||
|
||||
// calcul éventuel des normales aux noeuds -> init des normales pour t=0
|
||||
lesMail->InitNormaleAuxNoeuds(); //utilisé pour la stabilisation des membranes par ex
|
||||
|
||||
// ajout d'un conteneur pour les coordonnées à l'itération 0
|
||||
{Coordonnee coor(ParaGlob::Dimension()); // un type coordonnee typique
|
||||
Grandeur_coordonnee gt(coor); // une grandeur typique de type Grandeur_coordonnee
|
||||
|
|
@ -972,6 +984,8 @@ void AlgoBonelli::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
|
|||
{
|
||||
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
|
||||
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_EXP_BONELLI); // transfert info
|
||||
// init var glob: du num d'itération. De manière arbitraire, en dynamique explicite
|
||||
Transfert_ParaGlob_COMPTEUR_ITERATION_ALGO_GLOBAL(1); // on a toujours une seule itération
|
||||
OrdreVisu::EnumTypeIncre type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul
|
||||
|
||||
// préparation pour les aspects validation du calcul et sortie contrôlée des incréments
|
||||
|
|
@ -1424,8 +1438,8 @@ void AlgoBonelli::AvanceDDL_avec_CL(const Vecteur & phii,enuTypePhase phasage)
|
|||
for(ie=li_gene_asso.begin(),ih=1;ie!=iefin;ie++,ih++)
|
||||
{LesCondLim::Gene_asso & s = (*ie); // pour simplifier
|
||||
int ix=s.pointe(1); // début des Xi
|
||||
int iv=s.pointe(2); // début des Vi
|
||||
int ig=s.pointe(3); // début des gammai
|
||||
// int iv=s.pointe(2); // début des Vi
|
||||
// int ig=s.pointe(3); // début des gammai
|
||||
q_2(ix) = X_Bl(ih);
|
||||
q_1(ix) = X_t(ix);
|
||||
};
|
||||
|
|
@ -1474,8 +1488,8 @@ void AlgoBonelli::AvanceDDL_avec_CL(const Vecteur & phii,enuTypePhase phasage)
|
|||
for(ie=li_gene_asso.begin(),ih=1;ie!=iefin;ie++,ih++)
|
||||
{LesCondLim::Gene_asso & s = (*ie); // pour simplifier
|
||||
int ix=s.pointe(1); // début des Xi
|
||||
int iv=s.pointe(2); // début des Vi
|
||||
int ig=s.pointe(3); // début des gammai
|
||||
// int iv=s.pointe(2); // début des Vi
|
||||
// int ig=s.pointe(3); // début des gammai
|
||||
q_2(ix) = X_Bl(ih);
|
||||
q_1(ix) = X_t(ix);
|
||||
};
|
||||
3
herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h → Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h
Executable file → Normal file
3
herezh_pp/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h → Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -107,6 +107,7 @@ class AlgoBonelli : public Algori
|
|||
<< " l'algo passe en parametre est en fait : " << Nom_TypeCalcul(algo->TypeDeCalcul())
|
||||
<< " arret !! " << flush;
|
||||
Sortie(1);
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{ AlgoBonelli* inter = (AlgoBonelli*) algo;
|
||||
6
herezh_pp/Chargement/BlocCharge.cc → Chargement/BlocCharge.cc
Executable file → Normal file
6
herezh_pp/Chargement/BlocCharge.cc → Chargement/BlocCharge.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -93,7 +93,7 @@ void BlocScalVecTypeCharge::Lecture_champ_de_valeurs(UtilLecture & entreePrinc)
|
|||
{ list <double> lili; // une liste de travail
|
||||
// on va lire tant que l'on n'aura pas trouvé le mot clé de fin de champ
|
||||
entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
|
||||
while (strstr(entreePrinc.tablcar,"fin_champ_de_valeurs:")!=NULL)
|
||||
while (strstr(entreePrinc.tablcar,"fin_champ_de_valeurs:")==NULL)
|
||||
{ double grandeur;
|
||||
*(entreePrinc.entree) >> grandeur;
|
||||
// on contrôle le flux
|
||||
|
|
@ -873,7 +873,7 @@ void PTorseurPonct::Force(const Tableau <Coordonnee >& tab_P, Tableau <Coordonne
|
|||
{for (int i =1; i<= nb_Pi; i++)
|
||||
{Coordonnee& tab_P_i = tab_P(i);
|
||||
t_force(i) = Re ; // première partie du calcul de force
|
||||
G += tab_P(i) ;
|
||||
G += tab_P_i ;
|
||||
poids_total += 1.;
|
||||
};
|
||||
// d'où
|
||||
2
herezh_pp/Chargement/BlocCharge.h → Chargement/BlocCharge.h
Executable file → Normal file
2
herezh_pp/Chargement/BlocCharge.h → Chargement/BlocCharge.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Chargement/BlocCharge_T.h → Chargement/BlocCharge_T.h
Executable file → Normal file
2
herezh_pp/Chargement/BlocCharge_T.h → Chargement/BlocCharge_T.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
6
herezh_pp/Chargement/Charge.cc → Chargement/Charge.cc
Executable file → Normal file
6
herezh_pp/Chargement/Charge.cc → Chargement/Charge.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -758,7 +758,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon
|
|||
// dans le cas où il s'agit d'une ref relative à un champ, on vérifie que le nombre
|
||||
// de valeurs enregistrées correspond bien au nombre de noeuds
|
||||
if (tabPresUnif(i).Champ() != 0)
|
||||
{ if (tabPresUnif(i).DimVect() != ref.Taille())
|
||||
{ if (tabPresUnif(i).DimVal() != ref.Taille())
|
||||
{ cout << "\n ERREUR la reference: " << ref.Nom()
|
||||
<< " contiens "<<ref.Taille() << " facette "
|
||||
<< " alors que le champ de valeurs lues stocke "
|
||||
|
|
@ -1041,7 +1041,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon
|
|||
for (int i=1;i<= tabTorseurPonct.Taille();i++)
|
||||
{ { // recup de la reference correspondant au mot cle
|
||||
const Reference& ref = lesRef->Trouve(tabTorseurPonct(i).NomRef(),tabTorseurPonct(i).NomMaillage());
|
||||
const ReferenceNE & refN = ((ReferenceNE &) ref);
|
||||
//const ReferenceNE & refN = ((ReferenceNE &) ref);
|
||||
if (ref.Indic() != 1)
|
||||
// cas où la référence ne correspond pas à des noeuds
|
||||
{ cout << "\n ERREUR la reference: " << ref.Nom()
|
||||
2
herezh_pp/Chargement/Charge.h → Chargement/Charge.h
Executable file → Normal file
2
herezh_pp/Chargement/Charge.h → Chargement/Charge.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
16
herezh_pp/Chargement/Charge2.cc → Chargement/Charge2.cc
Executable file → Normal file
16
herezh_pp/Chargement/Charge2.cc → Chargement/Charge2.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -45,6 +45,11 @@ bool Charge::ChargeSecondMembre_Ex_mecaSolid
|
|||
(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef,Vecteur& vecglob
|
||||
,const ParaAlgoControle & pa,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, pour l'instant seule la (ou les) matrices du CPU 0 sont concernées
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
return true;
|
||||
#endif
|
||||
temps_cpu_chargement.Mise_en_route_du_comptage(); // temps cpu
|
||||
bool retour = true; // init par défaut
|
||||
try
|
||||
|
|
@ -1077,8 +1082,13 @@ bool Charge::ChargeSMembreRaideur_Im_mecaSolid
|
|||
const DdlElement& tab_ddl,const Tableau<Noeud *>&tab_noeud)
|
||||
,const ParaAlgoControle & pa
|
||||
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
|
||||
{
|
||||
temps_cpu_chargement.Mise_en_route_du_comptage();
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
// cas d'un calcul //, pour l'instant seule la (ou les) matrices du CPU 0 sont concernées
|
||||
if (ParaGlob::Monde()->rank() != 0)
|
||||
return true;
|
||||
#endif
|
||||
temps_cpu_chargement.Mise_en_route_du_comptage();
|
||||
bool retour = true; // init par défaut
|
||||
try
|
||||
{// pour tous les maillages, pour tous les éléments on effectue une initialisation éventuelle
|
||||
122
herezh_pp/Chargement/Charge3.cc → Chargement/Charge3.cc
Executable file → Normal file
122
herezh_pp/Chargement/Charge3.cc → Chargement/Charge3.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -1256,19 +1256,31 @@ void Charge::Precedent7()
|
|||
int Charge::Fin1(const int & icharge,bool affichage)
|
||||
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
|
||||
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
|
||||
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
|
||||
return 1;
|
||||
}
|
||||
// else if (icharge >= paAlgo->Maxincre())
|
||||
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
|
||||
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
|
||||
<< endl ;
|
||||
return 2;
|
||||
}
|
||||
else if (compteur_essai_increment > paAlgo->Max_essai_incre())
|
||||
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
else
|
||||
|
|
@ -1277,17 +1289,25 @@ int Charge::Fin1(const int & icharge,bool affichage)
|
|||
int Charge::Fin2(const int & icharge,bool affichage)
|
||||
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
|
||||
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
|
||||
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
// else if (icharge >= paAlgo->Maxincre())
|
||||
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
|
||||
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
|
||||
<< endl ;
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
|
||||
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
|
|
@ -1298,42 +1318,66 @@ int Charge::Fin2(const int & icharge,bool affichage)
|
|||
int Charge::Fin3(const int & icharge,bool affichage)
|
||||
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
|
||||
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
|
||||
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
// else if (icharge >= paAlgo->Maxincre())
|
||||
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
|
||||
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
|
||||
<< endl ;
|
||||
return 2;
|
||||
return 2;
|
||||
}
|
||||
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
|
||||
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
};
|
||||
int Charge::Fin4(const int & icharge,bool affichage)
|
||||
{ double temps = paAlgo->Variables_de_temps().TempsCourant();
|
||||
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
|
||||
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
// else if (icharge >= paAlgo->Maxincre())
|
||||
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
|
||||
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
|
||||
<< endl ;
|
||||
return 2;
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
|
||||
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
};
|
||||
|
|
@ -1342,25 +1386,41 @@ int Charge::Fin5(const int & icharge,bool affichage)
|
|||
CourbePolyLineaire1D* fconnue_charge = (CourbePolyLineaire1D*) f_charge;
|
||||
double temps = paAlgo->Variables_de_temps().TempsCourant(); // puis le temps
|
||||
if ((temps > paAlgo->Tempsfin()) || (Dabs(temps - paAlgo->Tempsfin()) <= paAlgo->Prectemps()))
|
||||
{ if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if ((ParaGlob::NiveauImpression() >= 1)&& affichage)
|
||||
{ cout << "\n >>>> temps fin ("<<paAlgo->Tempsfin()<<") atteint <<<<< " << temps << endl ;};
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else if ( num_pt_courant_type5 == fconnue_charge->NombrePoint())
|
||||
{ if (affichage) cout << "\n >>>> dernier temps de la courbe de charge atteint <<<<< " << endl ;
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n >>>> dernier temps de la courbe de charge atteint <<<<< " << endl ;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
// else if (icharge >= paAlgo->Maxincre())
|
||||
else if (icharge > paAlgo->Maxincre()) // modif 14 sept 2015
|
||||
{if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'increments fixes atteint : "<< paAlgo->Maxincre()
|
||||
<< "\n (pour info: maximum d'essai calcul increments = "<< paAlgo->Max_essai_incre()<<") "
|
||||
<< endl ;
|
||||
return 2;
|
||||
return 2;
|
||||
}
|
||||
else if (compteur_essai_increment >= paAlgo->Max_essai_incre())
|
||||
{if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
{
|
||||
#ifdef UTILISATION_MPI
|
||||
if (ParaGlob::Monde()->rank() == 0)
|
||||
#endif
|
||||
if (affichage) cout << "\n maximum d'essai d'increments fixes atteint : "<< paAlgo->Max_essai_incre() << endl ;
|
||||
return 3;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
};
|
||||
2
herezh_pp/Chargement/VariablesTemps.cc → Chargement/VariablesTemps.cc
Executable file → Normal file
2
herezh_pp/Chargement/VariablesTemps.cc → Chargement/VariablesTemps.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Chargement/VariablesTemps.h → Chargement/VariablesTemps.h
Executable file → Normal file
2
herezh_pp/Chargement/VariablesTemps.h → Chargement/VariablesTemps.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
43
herezh_pp/Elements/Element.cc → Elements/Element.cc
Executable file → Normal file
43
herezh_pp/Elements/Element.cc → Elements/Element.cc
Executable file → Normal file
|
|
@ -11,7 +11,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -792,7 +792,7 @@ Element::operator= (Element& elt)
|
|||
// en 2D: quadrangle: racine carré de la surface; triangle: racine carré de 2*surface
|
||||
// en 3D: hexa: racine cubique de vol; penta: racine cub de 2*vol, tétra: racine cub 6*vol
|
||||
// cas = 3: 1D idem cas 2, 2D: distance mini noeud arrête opposée, 3D: distance mini noeud face opposé
|
||||
double Element::LongueurGeometrique(int cas) const
|
||||
double Element::LongueurGeometrique_mini(int cas) const
|
||||
{ double longueur=0.; // valeur de retour
|
||||
switch (cas)
|
||||
{ case 1:
|
||||
|
|
@ -823,7 +823,7 @@ double Element::LongueurGeometrique(int cas) const
|
|||
// traitement d'une erreur éventuelle
|
||||
if (dist <= ConstMath::petit)
|
||||
{ cout << "\n **** ERREUR une longueur d'arrête de l'element est nulle"
|
||||
<< "\n Element::LongueurGeometrique(int cas)"
|
||||
<< "\n Element::LongueurGeometrique_mini(int cas)"
|
||||
<< "\n element: "; this->Affiche(1);
|
||||
#ifdef MISE_AU_POINT
|
||||
cout << "\n *** version mise au point: on continue neanmoins avec une longueur "
|
||||
|
|
@ -837,7 +837,7 @@ double Element::LongueurGeometrique(int cas) const
|
|||
}
|
||||
default :
|
||||
cout << "\nErreur : cas:" << cas <<" non encore traite !\n"
|
||||
<< "Element::LongueurGeometrique(int cas) ) \n";
|
||||
<< "Element::LongueurGeometrique_mini(int cas) ) \n";
|
||||
Sortie(1);
|
||||
}
|
||||
//cout << " longueur= "<< longueur << endl;
|
||||
|
|
@ -917,29 +917,34 @@ int Element::Num_de_frontiere_dans_le_type(int i) const
|
|||
{ // on supprime les cas hors du tableau tabb
|
||||
if (i<1) return 0;
|
||||
int tailletab = tabb.Taille();
|
||||
if (i>tailletab) return 0;
|
||||
// cas normal
|
||||
if (i <= posi_tab_front_lin)
|
||||
// cela veut dire que i est une surface car les premières frontières sont les surfaces, de plus i est directement le numéro de surface
|
||||
{ return i;}
|
||||
else if (i <= posi_tab_front_point)
|
||||
// cela veut dire que i est une ligne car les frontières après les surfaces sont les lignes
|
||||
{ return (i-posi_tab_front_lin); }
|
||||
else
|
||||
// cela veut dire que i est un point car les frontières après les lignes sont des points
|
||||
{ return (i-posi_tab_front_point);};
|
||||
};
|
||||
if (i>tailletab) return 0;
|
||||
// cas normal
|
||||
if (i <= posi_tab_front_lin)
|
||||
// cela veut dire que i est une surface car les premières frontières sont les surfaces, de plus i est directement le numéro de surface
|
||||
{ return i;}
|
||||
else if (i <= posi_tab_front_point)
|
||||
// cela veut dire que i est une ligne car les frontières après les surfaces sont les lignes
|
||||
{ return (i-posi_tab_front_lin); }
|
||||
else
|
||||
// cela veut dire que i est un point car les frontières après les lignes sont des points
|
||||
{ return (i-posi_tab_front_point);};
|
||||
};
|
||||
|
||||
// ramene le numero de la frontière passée en argument si elle existe actuellement au niveau de l'élément
|
||||
// sinon ramène 0
|
||||
// ramene également type_front: qui indique le type de frontière: POINT_G, LIGNE ou SURFACE
|
||||
// c'est une méthode très longue, a utiliser avec précaution
|
||||
int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front)
|
||||
int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front) const
|
||||
{ int num=0; type_front = RIEN_TYPE_GEOM; // initialisation du retour
|
||||
// on commence par balayer toutes les frontières pour trouver le numéro global
|
||||
int tail_tab=tabb.Taille();
|
||||
for (int i=1;i<=tail_tab;i++)
|
||||
if (fronti == (*tabb(i))) {num = i; break;}
|
||||
{// le tableau global peut avoir été correctement dimensionné
|
||||
// mais les éléments frontières peuvent avoir été supprimés
|
||||
if (tabb(i) != NULL) // cas où la frontière existe
|
||||
{if (fronti == (*tabb(i))) {num = i; break;}
|
||||
}
|
||||
};
|
||||
// si num est diff de 0 c'est ok, on recherche le type de frontière
|
||||
if (num != 0)
|
||||
{ // les frontières sont rangées selon: surface, ligne, point
|
||||
|
|
@ -950,7 +955,7 @@ int Element::Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front
|
|||
else if ((num > posi_tab_front_lin)&&(ind_front_lin!=0)) {type_front = LIGNE;num -= posi_tab_front_lin;}
|
||||
// si ce n'est ni un point ni une ligne, vue que ça doit-être quelque chose ça ne peut être qu'une surface
|
||||
else {type_front = SURFACE;}; // et num a directement la bonne valeur que ce sont d'abord les faces qui sont stockées
|
||||
}
|
||||
};
|
||||
// retour des infos
|
||||
return num;
|
||||
};
|
||||
31
herezh_pp/Elements/Element.h → Elements/Element.h
Executable file → Normal file
31
herezh_pp/Elements/Element.h → Elements/Element.h
Executable file → Normal file
|
|
@ -10,7 +10,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -39,6 +39,8 @@
|
|||
#ifndef ELEMENT_H
|
||||
#define ELEMENT_H
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
#include <iostream>
|
||||
#include <stdlib.h>
|
||||
|
|
@ -297,6 +299,8 @@ class Element
|
|||
// pour le schema implicite
|
||||
class ResRaid { public : Vecteur* res; Mat_pleine * raid ; };
|
||||
virtual ResRaid Calcul_implicit (const ParaAlgoControle & pa ) = 0;
|
||||
// récup uniquement du conteneur raideur (pas forcément rempli, mais de la bonne taille)
|
||||
Mat_pleine * Conteneur_raideur () {return raideur; };
|
||||
|
||||
// Calcul du residu local a l'instant t
|
||||
// pour le schema explicit, resultat dans le vecteur pointe
|
||||
|
|
@ -305,6 +309,8 @@ class Element
|
|||
// Calcul du residu local a l'instant tdt
|
||||
// pour le schema explicit, resultat dans le vecteur pointe
|
||||
virtual Vecteur* CalculResidu_tdt (const ParaAlgoControle & pa) = 0;
|
||||
// récup uniquement du conteneur résidu (pas forcément rempli, mais de la bonne taille)
|
||||
Vecteur* Conteneur_Residu () {return residu;};
|
||||
|
||||
// Calcul de la matrice masse pour l'élément
|
||||
virtual Mat_pleine * CalculMatriceMasse (Enum_calcul_masse id_calcul_masse) = 0;
|
||||
|
|
@ -336,7 +342,7 @@ class Element
|
|||
// en 2D: quadrangle: racine carré de la surface; triangle: racine carré de 2*surface
|
||||
// en 3D: hexa: racine cubique de vol; penta: racine cub de 2*vol, tétra: racine cub 6*vol
|
||||
// cas = 3: 1D idem cas 2, 2D: distance mini noeud arrête opposée, 3D: distance mini noeud face opposé
|
||||
double LongueurGeometrique(int cas) const;
|
||||
double LongueurGeometrique_mini(int cas) const;
|
||||
// récupération du volume de l'élément (qui doit avoir été calculé dans une des classes dérivées
|
||||
// par exemple en mécanique via un calcul explicite ou implicite d'équilibre mécanique
|
||||
// pour un élément 3D: le volume au sens classique
|
||||
|
|
@ -601,14 +607,14 @@ class Element
|
|||
// ============ Calcul des frontieres de l'element================
|
||||
|
||||
// tout d'abord une explication sur la terminologie
|
||||
// on appelle frontières de l'éléments les frontières naturelles c'est-à-dire
|
||||
// on appelle frontières minimales de l'éléments les frontières naturelles c'est-à-dire
|
||||
// pour les éléments 1D : les noeuds aux l'extrémitées en monde 1D
|
||||
// sinon également l'élément en monde 2D et 3D
|
||||
// pour les éléments 2D : les arrêtes de l'élément en monde 2D
|
||||
// sinon également la surface de l'élément en monde 2D et 3D
|
||||
// pour les éléments 3D : les surfaces externes de l'élément
|
||||
|
||||
// Calcul des frontieres de l'element et retour d'un tableau tabb des frontières
|
||||
// Calcul des frontieres minimales de l'element et retour d'un tableau tabb des frontières
|
||||
// creation des elements frontieres et stockage dans l'element
|
||||
// si c'est la première fois sinon il y a seulement retour du tableau de ces elements
|
||||
// a moins que le paramètre force est mis a true dans ce dernier cas seul les frontière effacées sont recréée
|
||||
|
|
@ -675,7 +681,22 @@ class Element
|
|||
// sinon ramène 0
|
||||
// ramene également type_front: qui indique le type de frontière: POINT_G, LIGNE ou SURFACE
|
||||
// c'est une méthode très longue, a utiliser avec précaution
|
||||
int Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front);
|
||||
int Num_frontiere(const ElFrontiere& fronti, Enum_type_geom& type_front) const;
|
||||
|
||||
// Calcul spécifiques des frontieres de l'element et retour d'un tableau tabb des frontières
|
||||
// creation des elements frontieres et stockage dans l'element
|
||||
// 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
|
||||
// cas :
|
||||
// = 0 -> on veut toutes les frontières
|
||||
// = 1 -> on veut uniquement les surfaces
|
||||
// = 2 -> on veut uniquement les lignes
|
||||
// = 3 -> on veut uniquement les points
|
||||
// = 4 -> on veut les surfaces + les lignes
|
||||
// = 5 -> on veut les surfaces + les points
|
||||
// = 6 -> on veut les lignes + les points
|
||||
// virtual Tableau <ElFrontiere*> const & Frontiere_specifique(int cas, bool force = false) = 0;
|
||||
|
||||
// mise à jour de la boite d'encombrement de l'élément, suivant les axes I_a globales
|
||||
// en retour coordonnées du point mini dans retour.Premier() et du point maxi dans .Second()
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.cc → Elements/Geometrie/ElemGeom/ElemGeomC0.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.cc → Elements/Geometrie/ElemGeom/ElemGeomC0.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
10
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.h → Elements/Geometrie/ElemGeom/ElemGeomC0.h
Executable file → Normal file
10
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC0.h → Elements/Geometrie/ElemGeom/ElemGeomC0.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -114,13 +114,13 @@ class ElemGeomC0
|
|||
// retourne les coordonnees du point d'integration i
|
||||
inline Coordonnee const & CoorPtInteg(int i) const { return ptInteg(i);};
|
||||
// retourne les fonctions d'interpolation au point d'integration i
|
||||
inline Vecteur const & Phi(int i) { return tabPhi(i);};
|
||||
inline Vecteur const & Phi(int i) const { return tabPhi(i);};
|
||||
// retourne les tableau de fonctions d'interpolation
|
||||
inline Tableau <Vecteur> const & TaPhi() const { return tabPhi;};
|
||||
// retourne les derivees des fonctions d'interpolation au point d'integration i
|
||||
inline Mat_pleine const& Dphi(int i) { return tabDPhi(i);};
|
||||
// retourne le tableau des derivees des fonctions d'interpolation
|
||||
inline Tableau < Mat_pleine > const& TaDphi() { return tabDPhi;};
|
||||
inline Tableau < Mat_pleine > const& TaDphi() const { return tabDPhi;};
|
||||
// retourne les poids d'integration du point d'integration i
|
||||
inline double Wi(int i) const { return WI(i);};
|
||||
// retourne le vecteur des poids d'integration
|
||||
|
|
@ -200,9 +200,9 @@ class ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
virtual const Vecteur& Phi(const Coordonnee& M) = 0;
|
||||
virtual const Vecteur& Phi_point(const Coordonnee& M) = 0;
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
virtual const Mat_pleine& Dphi(const Coordonnee& M) = 0;
|
||||
virtual const Mat_pleine& Dphi_point(const Coordonnee& M) = 0;
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
virtual bool Interieur(const Coordonnee& M) = 0;
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC1.h → Elements/Geometrie/ElemGeom/ElemGeomC1.h
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/ElemGeomC1.h → Elements/Geometrie/ElemGeom/ElemGeomC1.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc → Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc → Elements/Geometrie/ElemGeom/Ligne/GeomSeg.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -339,7 +339,7 @@ ElemGeomC0 * GeomSeg::newElemGeomC0(ElemGeomC0 * pt)
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomSeg::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomSeg::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -381,7 +381,7 @@ const Vecteur& GeomSeg::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomSeg::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomSeg::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h → Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h → Elements/Geometrie/ElemGeom/Ligne/GeomSeg.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -114,9 +114,9 @@ class GeomSeg : public ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.cc → Elements/Geometrie/ElemGeom/Point/GeomPoint.cc
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.cc → Elements/Geometrie/ElemGeom/Point/GeomPoint.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -82,7 +82,7 @@ ElemGeomC0 * GeomPoint::newElemGeomC0(ElemGeomC0 * pt)
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomPoint::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomPoint::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -99,7 +99,7 @@ const Vecteur& GeomPoint::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomPoint::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomPoint::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.h → Elements/Geometrie/ElemGeom/Point/GeomPoint.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/Point/GeomPoint.h → Elements/Geometrie/ElemGeom/Point/GeomPoint.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -84,9 +84,9 @@ class GeomPoint : public ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
12
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc → Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc
Executable file → Normal file
12
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc → Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -531,7 +531,7 @@ ElemGeomC0 * GeomQuadrangle::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomQuadrangle::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomQuadrangle::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -559,7 +559,7 @@ const Vecteur& GeomQuadrangle::Phi(const Coordonnee& M)
|
|||
Vecteur tabPhiT(NBNE);
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy);
|
||||
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -644,7 +644,7 @@ const Vecteur& GeomQuadrangle::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomQuadrangle::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomQuadrangle::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -673,8 +673,8 @@ const Mat_pleine& GeomQuadrangle::Dphi(const Coordonnee& M)
|
|||
Mat_pleine tabDPhiT(2,NBNE);
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy);
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h → Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h → Elements/Geometrie/ElemGeom/surface/GeomQuadrangle.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -162,9 +162,9 @@ class GeomQuadrangle : public ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc → Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc → Elements/Geometrie/ElemGeom/surface/GeomTriangle.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -590,7 +590,7 @@ ElemGeomC0 * GeomTriangle::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomTriangle::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomTriangle::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -692,7 +692,7 @@ const Vecteur& GeomTriangle::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomTriangle::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomTriangle::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.h → Elements/Geometrie/ElemGeom/surface/GeomTriangle.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/surface/GeomTriangle.h → Elements/Geometrie/ElemGeom/surface/GeomTriangle.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -147,9 +147,9 @@ class GeomTriangle : public ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaCom.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h → Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h → Elements/Geometrie/ElemGeom/volume/GeomHexaCom.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -172,9 +172,9 @@ GeomHexaCubique::GeomHexaCubique(int nbi) :
|
|||
// on utilise les méthodes internes pour calculer les fonctions
|
||||
// d'interpolation aux points d'intégrations
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
|
|
@ -246,7 +246,7 @@ ElemGeomC0 * GeomHexaCubique::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomHexaCubique::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomHexaCubique::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -274,7 +274,7 @@ const Vecteur& GeomHexaCubique::Phi(const Coordonnee& M)
|
|||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
|
||||
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -307,7 +307,7 @@ const Vecteur& GeomHexaCubique::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomHexaCubique::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomHexaCubique::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -336,9 +336,9 @@ const Mat_pleine& GeomHexaCubique::Dphi(const Coordonnee& M)
|
|||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(3,ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Dphi(Z)(1,iz);
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(3,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Dphi_point(Z)(1,iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -59,7 +59,7 @@
|
|||
// l'élément cubique complet
|
||||
|
||||
/*
|
||||
//***********************************************************************
|
||||
// ***********************************************************************
|
||||
// *
|
||||
// ELEMENT DE REFERENCE , POINTS D'INTEGRATION: *
|
||||
// *
|
||||
|
|
@ -262,9 +262,9 @@ class GeomHexaCubique : public GeomHexaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
20
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc
Executable file → Normal file
20
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.cc
Executable file → Normal file
|
|
@ -10,7 +10,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -146,21 +146,21 @@ GeomHexaQuad::GeomHexaQuad(int nbi) :
|
|||
{ // on utilise les méthodes internes pour calculer les fonctions
|
||||
// d'interpolation aux points d'intégrations
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
}
|
||||
|
||||
// vérification suivant OK a priori
|
||||
// essai de calcul directe des fonctions d'interpolation
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint)); //*/
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint)); //*/
|
||||
// vérification des fonctions d'interpolation analytique et numériques
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
{
|
||||
Vecteur a = tabPhi(ptint);Vecteur b = Phi( ptInteg(ptint));
|
||||
Vecteur a = tabPhi(ptint);Vecteur b = Phi_point( ptInteg(ptint));
|
||||
for (int ne=1;ne<= NBNE;ne++)
|
||||
if (Dabs(a(ne) - b(ne)) >= 1.E-14)
|
||||
{
|
||||
|
|
@ -173,7 +173,7 @@ GeomHexaQuad::GeomHexaQuad(int nbi) :
|
|||
// et numériques
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
{
|
||||
Mat_pleine a = tabDPhi(ptint);Mat_pleine b = Dphi( ptInteg(ptint));
|
||||
Mat_pleine a = tabDPhi(ptint);Mat_pleine b = Dphi_point( ptInteg(ptint));
|
||||
for (int ne=1;ne<= NBNE;ne++)
|
||||
for (int ia =1; ia<= 3; ia++)
|
||||
if (Dabs(a(ia,ne) - b(ia,ne)) >= 1.E-14)
|
||||
|
|
@ -218,7 +218,7 @@ ElemGeomC0 * GeomHexaQuad::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomHexaQuad::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomHexaQuad::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -275,7 +275,7 @@ const Vecteur& GeomHexaQuad::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomHexaQuad::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomHexaQuad::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -428,7 +428,7 @@ void GeomHexaQuad::Calcul_extrapol(int nbi)
|
|||
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = hexa.Phi(theta);
|
||||
const Vecteur& phiphi = hexa.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(8);
|
||||
tab(ne).Change_taille(nbi);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -239,9 +239,9 @@ class GeomHexaQuad : public GeomHexaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuad2.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
24
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc
Executable file → Normal file
24
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc → Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -149,9 +149,9 @@ GeomHexaQuadComp::GeomHexaQuadComp(int nbi) :
|
|||
// on utilise les méthodes internes pour calculer les fonctions
|
||||
// d'interpolation aux points d'intégrations
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
|
|
@ -223,7 +223,7 @@ ElemGeomC0 * GeomHexaQuadComp::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomHexaQuadComp::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomHexaQuadComp::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -251,7 +251,7 @@ const Vecteur& GeomHexaQuadComp::Phi(const Coordonnee& M)
|
|||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
|
||||
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -284,7 +284,7 @@ const Vecteur& GeomHexaQuadComp::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomHexaQuadComp::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomHexaQuadComp::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -313,9 +313,9 @@ const Mat_pleine& GeomHexaQuadComp::Dphi(const Coordonnee& M)
|
|||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(3,ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Dphi(Z)(1,iz);
|
||||
{ tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(2,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Dphi_point(Y)(1,iy) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(3,ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Dphi_point(Z)(1,iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -435,7 +435,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
|
|||
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = hexa.Phi(theta);
|
||||
const Vecteur& phiphi = hexa.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(8);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -738,7 +738,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
|
|||
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = hexa.Phi(theta);
|
||||
const Vecteur& phiphi = hexa.Phi_point(theta);
|
||||
// et on enregistre
|
||||
// on boucle sur les pti de l'hexa linéaire d'interpolation
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -991,7 +991,7 @@ void GeomHexaQuadComp::Calcul_extrapol(int nbi)
|
|||
}
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = hexa.Phi(theta);
|
||||
const Vecteur& phiphi = hexa.Phi_point(theta);
|
||||
// et on enregistre
|
||||
tab(ne).Change_taille(nbi);
|
||||
// on boucle sur les pti de l'hexa linéaire d'interpolation
|
||||
8
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h → Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h
Executable file → Normal file
8
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h → Elements/Geometrie/ElemGeom/volume/GeomHexaQuadComp.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -60,7 +60,7 @@
|
|||
|
||||
|
||||
/*
|
||||
//***********************************************************************
|
||||
// ***********************************************************************
|
||||
// *
|
||||
// ELEMENT DE REFERENCE , POINTS D'INTEGRATION: *
|
||||
// *
|
||||
|
|
@ -243,9 +243,9 @@ class GeomHexaQuadComp : public GeomHexaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
30
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin.cc → Elements/Geometrie/ElemGeom/volume/GeomHexalin.cc
Executable file → Normal file
30
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin.cc → Elements/Geometrie/ElemGeom/volume/GeomHexalin.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -114,9 +114,9 @@ GeomHexalin::GeomHexalin(int nbi ) :
|
|||
{ // on utilise les méthodes internes pour calculer les fonctions
|
||||
// d'interpolation aux points d'intégrations
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
for (int ptint=1;ptint<= Nbi(); ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
};
|
||||
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
|
|
@ -153,7 +153,7 @@ ElemGeomC0 * GeomHexalin::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomHexalin::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomHexalin::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -180,7 +180,7 @@ const Vecteur& GeomHexalin::Phi(const Coordonnee& M)
|
|||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
for (int iy = 1;iy<= nbnes; iy++)
|
||||
for (int ix =1;ix<=nbnes;ix++)
|
||||
{ tabPhiT(ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Phi(Z)(iz);
|
||||
{ tabPhiT(ne) = seg(1)->Phi_point(X)(ix) * seg(1)->Phi_point(Y)(iy) * seg(1)->Phi_point(Z)(iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -202,7 +202,7 @@ const Vecteur& GeomHexalin::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomHexalin::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomHexalin::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -234,12 +234,12 @@ const Mat_pleine& GeomHexalin::Dphi(const Coordonnee& M)
|
|||
//tabDPhiT(2,ne) = seg(1)->Phi(X)(ix) * seg(1)->Dphi(Y)(1,iy) * seg(1)->Phi(Z)(iz);
|
||||
//tabDPhiT(3,ne) = seg(1)->Phi(X)(ix) * seg(1)->Phi(Y)(iy) * seg(1)->Dphi(Z)(1,iz);
|
||||
|
||||
double phi_X_ix = seg(1)->Phi(X)(ix);
|
||||
double phi_Y_iy = seg(1)->Phi(Y)(iy);
|
||||
double phi_Z_iz = seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(1,ne) = seg(1)->Dphi(X)(1,ix) * phi_Y_iy * phi_Z_iz;
|
||||
tabDPhiT(2,ne) = phi_X_ix * seg(1)->Dphi(Y)(1,iy) * phi_Z_iz;
|
||||
tabDPhiT(3,ne) = phi_X_ix * phi_Y_iy * seg(1)->Dphi(Z)(1,iz);
|
||||
double phi_X_ix = seg(1)->Phi_point(X)(ix);
|
||||
double phi_Y_iy = seg(1)->Phi_point(Y)(iy);
|
||||
double phi_Z_iz = seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(1,ne) = seg(1)->Dphi_point(X)(1,ix) * phi_Y_iy * phi_Z_iz;
|
||||
tabDPhiT(2,ne) = phi_X_ix * seg(1)->Dphi_point(Y)(1,iy) * phi_Z_iz;
|
||||
tabDPhiT(3,ne) = phi_X_ix * phi_Y_iy * seg(1)->Dphi_point(Z)(1,iz);
|
||||
|
||||
ne++;
|
||||
}
|
||||
|
|
@ -345,7 +345,7 @@ void GeomHexalin::Calcul_extrapol(int nbi)
|
|||
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -534,7 +534,7 @@ void GeomHexalin::Calcul_extrapol(int nbi)
|
|||
}
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
tab(ne).Change_taille(nbi);
|
||||
// on boucle sur les pti de l'hexa linéaire d'interpolation
|
||||
|
|
@ -658,7 +658,7 @@ void GeomHexalin::Calcul_extrapol(int nbi)
|
|||
}
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
tab(ne).Change_taille(nbi);
|
||||
// on boucle sur les pti de l'hexa linéaire d'interpolation
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin.h → Elements/Geometrie/ElemGeom/volume/GeomHexalin.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin.h → Elements/Geometrie/ElemGeom/volume/GeomHexalin.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -234,9 +234,9 @@ class GeomHexalin : public GeomHexaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin2.cc → Elements/Geometrie/ElemGeom/volume/GeomHexalin2.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomHexalin2.cc → Elements/Geometrie/ElemGeom/volume/GeomHexalin2.cc
Executable file → Normal file
|
|
@ -9,7 +9,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaCom.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaCom.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaCom.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaCom.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaCom.h → Elements/Geometrie/ElemGeom/volume/GeomPentaCom.h
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaCom.h → Elements/Geometrie/ElemGeom/volume/GeomPentaCom.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
30
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaL.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaL.cc
Executable file → Normal file
30
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaL.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaL.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -115,10 +115,10 @@ GeomPentaL::GeomPentaL(int nbi) :
|
|||
};
|
||||
// fonctions d'interpolation globales aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
// derivees des fonctions d'interpolations aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
|
||||
|
|
@ -158,7 +158,7 @@ ElemGeomC0 * GeomPentaL::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomPentaL::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomPentaL::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -182,14 +182,14 @@ const Vecteur& GeomPentaL::Phi(const Coordonnee& M)
|
|||
int ne = 1;
|
||||
for (int iz = 1;iz<= nbnel; iz++)
|
||||
for (int ix = 1;ix<= nbnes; ix++)
|
||||
{ phi_M(ne) = seg(1)->Phi(Z)(iz) * face(1)->Phi(X)(ix) ;
|
||||
{ phi_M(ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Phi_point(X)(ix) ;
|
||||
ne++;
|
||||
};
|
||||
// retour de phi_M
|
||||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomPentaL::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomPentaL::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -213,9 +213,9 @@ const Mat_pleine& GeomPentaL::Dphi(const Coordonnee& M)
|
|||
int ne = 1;
|
||||
for (int iz = 1;iz<= nbnel; iz++)
|
||||
for (int ix = 1;ix<= nbnes; ix++)
|
||||
{ dphi_M(1,ne) = seg(1)->Phi(Z)(iz) * face(1)->Dphi(X)(1,ix) ;
|
||||
dphi_M(2,ne) = seg(1)->Phi(Z)(iz) * face(1)->Dphi(X)(2,ix) ;
|
||||
dphi_M(3,ne) = seg(1)->Dphi(Z)(1,iz) * face(1)->Phi(X)(ix) ;
|
||||
{ dphi_M(1,ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Dphi_point(X)(1,ix) ;
|
||||
dphi_M(2,ne) = seg(1)->Phi_point(Z)(iz) * face(1)->Dphi_point(X)(2,ix) ;
|
||||
dphi_M(3,ne) = seg(1)->Dphi_point(Z)(1,iz) * face(1)->Phi_point(X)(ix) ;
|
||||
ne++;
|
||||
};
|
||||
// retour des derivees
|
||||
|
|
@ -454,7 +454,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud de la facette la valeur extrapolée
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre this
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -504,7 +504,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud de la facette la valeur extrapolée
|
||||
// maintenant on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre this
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -650,7 +650,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(6);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -752,7 +752,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -902,7 +902,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1080,7 +1080,7 @@ void GeomPentaL::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = this->Phi(theta);
|
||||
const Vecteur& phiphi = this->Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaL.h → Elements/Geometrie/ElemGeom/volume/GeomPentaL.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaL.h → Elements/Geometrie/ElemGeom/volume/GeomPentaL.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -139,9 +139,9 @@ class GeomPentaL : public GeomPentaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
26
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQ.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaQ.cc
Executable file → Normal file
26
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQ.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaQ.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -143,10 +143,10 @@ GeomPentaQ::GeomPentaQ(int nbi) :
|
|||
|
||||
// fonctions d'interpolation globales aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
// derivees des fonctions d'interpolations aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
|
||||
|
|
@ -186,7 +186,7 @@ ElemGeomC0 * GeomPentaQ::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomPentaQ::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomPentaQ::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -202,7 +202,7 @@ const Vecteur& GeomPentaQ::Phi(const Coordonnee& M)
|
|||
phi_M.Change_taille(NBNE); // si la taille est identique -> aucune action
|
||||
|
||||
// construction à partir des triangles des faces
|
||||
Vecteur phisurf=face(1)->Phi(Coordonnee(M(1),M(2)));
|
||||
Vecteur phisurf=face(1)->Phi_point(Coordonnee(M(1),M(2)));
|
||||
double KSI = M(1); double ETA = M(2); double DZETA = M(3);
|
||||
double fsup=(1.+ DZETA)*DZETA/2.; double finf=-(1.-DZETA)*DZETA/2.;
|
||||
double LAMBDA= 1. - KSI - ETA; double C = 1. - DZETA*DZETA;
|
||||
|
|
@ -250,7 +250,7 @@ const Vecteur& GeomPentaQ::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomPentaQ::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomPentaQ::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -266,8 +266,8 @@ const Mat_pleine& GeomPentaQ::Dphi(const Coordonnee& M)
|
|||
if ((dphi_M.Nb_ligne() != 3)&&(dphi_M.Nb_colonne() != NBNE))
|
||||
dphi_M.Initialise (3,NBNE,0.);
|
||||
// construction à partir des triangles des faces
|
||||
Vecteur phisurf=face(1)->Phi(Coordonnee(M(1),M(2)));
|
||||
Mat_pleine dphisurf=face(1)->Dphi(Coordonnee(M(1),M(2)));
|
||||
Vecteur phisurf=face(1)->Phi_point(Coordonnee(M(1),M(2)));
|
||||
Mat_pleine dphisurf=face(1)->Dphi_point(Coordonnee(M(1),M(2)));
|
||||
double KSI = M(1); double ETA = M(2); double DZETA = M(3);
|
||||
double fsup=(1.+ DZETA)*DZETA/2.; double finf=-(1.-DZETA)*DZETA/2.;
|
||||
double dfsup=(1.+ 2.*DZETA)/2.; double dfinf=(2.*DZETA-1.)/2.;
|
||||
|
|
@ -847,7 +847,7 @@ void GeomPentaQ::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1013,7 +1013,7 @@ void GeomPentaQ::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(6);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1148,7 +1148,7 @@ void GeomPentaQ::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1316,7 +1316,7 @@ void GeomPentaQ::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1517,7 +1517,7 @@ void GeomPentaQ::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQ.h → Elements/Geometrie/ElemGeom/volume/GeomPentaQ.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQ.h → Elements/Geometrie/ElemGeom/volume/GeomPentaQ.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -139,9 +139,9 @@ class GeomPentaQ : public GeomPentaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
28
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.cc
Executable file → Normal file
28
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.cc → Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -144,10 +144,10 @@ GeomPentaQComp::GeomPentaQComp(int nbi) :
|
|||
|
||||
// fonctions d'interpolation globales aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabPhi(ptint) = Phi( ptInteg(ptint));
|
||||
tabPhi(ptint) = Phi_point( ptInteg(ptint));
|
||||
// derivees des fonctions d'interpolations aux points d'intégrations
|
||||
for (int ptint=1;ptint<= nbi; ptint++)
|
||||
tabDPhi(ptint) = Dphi( ptInteg(ptint));
|
||||
tabDPhi(ptint) = Dphi_point( ptInteg(ptint));
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
|
||||
|
|
@ -187,7 +187,7 @@ ElemGeomC0 * GeomPentaQComp::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomPentaQComp::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomPentaQComp::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -214,7 +214,7 @@ const Vecteur& GeomPentaQComp::Phi(const Coordonnee& M)
|
|||
Vecteur tabPhiT(NBNE);
|
||||
for (int ifa = 1;ifa<= nbnef; ifa++)
|
||||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
{ tabPhiT(ne) = face(1)->Phi(XY)(ifa) * seg(1)->Phi(Z)(iz);
|
||||
{ tabPhiT(ne) = face(1)->Phi_point(XY)(ifa) * seg(1)->Phi_point(Z)(iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -243,7 +243,7 @@ const Vecteur& GeomPentaQComp::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomPentaQComp::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomPentaQComp::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -271,9 +271,9 @@ const Mat_pleine& GeomPentaQComp::Dphi(const Coordonnee& M)
|
|||
Mat_pleine tabDPhiT(3,NBNE);
|
||||
for (int ifa = 1;ifa<= nbnef; ifa++)
|
||||
for (int iz = 1;iz<= nbnes; iz++)
|
||||
{ tabDPhiT(1,ne) = face(1)->Dphi(XY)(1,ifa) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(2,ne) = face(1)->Dphi(XY)(2,ifa) * seg(1)->Phi(Z)(iz);
|
||||
tabDPhiT(3,ne) = face(1)->Phi(XY)(ifa) * seg(1)->Dphi(Z)(1,iz);
|
||||
{ tabDPhiT(1,ne) = face(1)->Dphi_point(XY)(1,ifa) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(2,ne) = face(1)->Dphi_point(XY)(2,ifa) * seg(1)->Phi_point(Z)(iz);
|
||||
tabDPhiT(3,ne) = face(1)->Phi_point(XY)(ifa) * seg(1)->Dphi_point(Z)(1,iz);
|
||||
ne++;
|
||||
}
|
||||
// numerotation suivant le standard habituel
|
||||
|
|
@ -517,7 +517,7 @@ void GeomPentaQComp::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -698,7 +698,7 @@ void GeomPentaQComp::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(6);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -843,7 +843,7 @@ void GeomPentaQComp::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1018,7 +1018,7 @@ void GeomPentaQComp::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
|
|
@ -1223,7 +1223,7 @@ void GeomPentaQComp::Calcul_extrapol(int nbi)
|
|||
// maintenant on va attribuer au noeud la valeur extrapolée
|
||||
// on calcule les fct d'interpolation au noeud ne
|
||||
// via ses coordonnées locales theta: on utilise le pentaèdre linéaire
|
||||
const Vecteur& phiphi = penta.Phi(theta);
|
||||
const Vecteur& phiphi = penta.Phi_point(theta);
|
||||
// et on enregistre
|
||||
indir(ne).Change_taille(nbi);
|
||||
tab(ne).Change_taille(nbi);
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.h → Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.h → Elements/Geometrie/ElemGeom/volume/GeomPentaQComp.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -141,9 +141,9 @@ class GeomPentaQComp : public GeomPentaCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
|
||||
protected :
|
||||
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetra.h → Elements/Geometrie/ElemGeom/volume/GeomTetra.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetra.h → Elements/Geometrie/ElemGeom/volume/GeomTetra.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -149,9 +149,9 @@ class GeomHexalin : public ElemGeomC0
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraCom.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraCom.cc
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraCom.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraCom.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraCom.h → Elements/Geometrie/ElemGeom/volume/GeomTetraCom.h
Executable file → Normal file
2
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraCom.h → Elements/Geometrie/ElemGeom/volume/GeomTetraCom.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
10
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraL.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraL.cc
Executable file → Normal file
10
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraL.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraL.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -106,10 +106,10 @@ GeomTetraL::GeomTetraL(int nbi) :
|
|||
}
|
||||
// calcul des fonctions d'interpolations aux points d'intégration
|
||||
for (int i =1;i<=Nbi();i++)
|
||||
tabPhi(i)= Phi(ptInteg(i));
|
||||
tabPhi(i)= Phi_point(ptInteg(i));
|
||||
// calcul des dérivées des fonctions d'interpolations aux points d'intégration
|
||||
for (int i =1;i<=Nbi();i++)
|
||||
tabDPhi(i)= Dphi(ptInteg(i));
|
||||
tabDPhi(i)= Dphi_point(ptInteg(i));
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
};
|
||||
|
|
@ -144,7 +144,7 @@ ElemGeomC0 * GeomTetraL::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomTetraL::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomTetraL::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -168,7 +168,7 @@ const Vecteur& GeomTetraL::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomTetraL::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomTetraL::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraL.h → Elements/Geometrie/ElemGeom/volume/GeomTetraL.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraL.h → Elements/Geometrie/ElemGeom/volume/GeomTetraL.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -145,9 +145,9 @@ class GeomTetraL : public GeomTetraCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
10
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraQ.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraQ.cc
Executable file → Normal file
10
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraQ.cc → Elements/Geometrie/ElemGeom/volume/GeomTetraQ.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -122,7 +122,7 @@ GeomTetraQ::GeomTetraQ(int nbi) :
|
|||
|
||||
// calcul des fonctions d'interpolations aux points d'intégration
|
||||
for (int i =1;i<=Nbi();i++)
|
||||
tabPhi(i)= Phi(ptInteg(i));
|
||||
tabPhi(i)= Phi_point(ptInteg(i));
|
||||
|
||||
////---debug
|
||||
//// for (int i =1;i<=10;i++)
|
||||
|
|
@ -150,7 +150,7 @@ GeomTetraQ::GeomTetraQ(int nbi) :
|
|||
|
||||
// calcul des dérivées des fonctions d'interpolations aux points d'intégration
|
||||
for (int i =1;i<=Nbi();i++)
|
||||
tabDPhi(i)= Dphi(ptInteg(i));
|
||||
tabDPhi(i)= Dphi_point(ptInteg(i));
|
||||
// ---- constitution du tableau Extrapol -----
|
||||
Calcul_extrapol(nbi);
|
||||
};
|
||||
|
|
@ -185,7 +185,7 @@ ElemGeomC0 * GeomTetraQ::newElemGeomC0(ElemGeomC0 * pt)
|
|||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& GeomTetraQ::Phi(const Coordonnee& M)
|
||||
const Vecteur& GeomTetraQ::Phi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
|
|
@ -223,7 +223,7 @@ const Vecteur& GeomTetraQ::Phi(const Coordonnee& M)
|
|||
return phi_M;
|
||||
};
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& GeomTetraQ::Dphi(const Coordonnee& M)
|
||||
const Mat_pleine& GeomTetraQ::Dphi_point(const Coordonnee& M)
|
||||
{
|
||||
#ifdef MISE_AU_POINT
|
||||
// verification de la dimension des coordonnees locales
|
||||
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraQ.h → Elements/Geometrie/ElemGeom/volume/GeomTetraQ.h
Executable file → Normal file
6
herezh_pp/Elements/Geometrie/ElemGeom/volume/GeomTetraQ.h → Elements/Geometrie/ElemGeom/volume/GeomTetraQ.h
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -147,9 +147,9 @@ class GeomTetraQ : public GeomTetraCom
|
|||
|
||||
//--------- cas de coordonnees locales quelconques ----------------
|
||||
// retourne les fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Vecteur& Phi(const Coordonnee& M);
|
||||
const Vecteur& Phi_point(const Coordonnee& M);
|
||||
// retourne les derivees des fonctions d'interpolation au point M (en coordonnees locales)
|
||||
const Mat_pleine& Dphi(const Coordonnee& M);
|
||||
const Mat_pleine& Dphi_point(const Coordonnee& M);
|
||||
// en fonction de coordonnees locales, retourne true si le point est a l'interieur
|
||||
// de l'element, false sinon
|
||||
bool Interieur(const Coordonnee& M);
|
||||
247
herezh_pp/Elements/Geometrie/Frontiere/ElFrontiere.cc → Elements/Geometrie/Frontiere/ElFrontiere.cc
Executable file → Normal file
247
herezh_pp/Elements/Geometrie/Frontiere/ElFrontiere.cc → Elements/Geometrie/Frontiere/ElFrontiere.cc
Executable file → Normal file
|
|
@ -8,7 +8,7 @@
|
|||
//
|
||||
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
||||
//
|
||||
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
||||
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
||||
// AUTHOR : Gérard Rio
|
||||
// E-MAIL : gerardrio56@free.fr
|
||||
//
|
||||
|
|
@ -91,7 +91,7 @@ bool ElFrontiere::operator == ( const ElFrontiere& a) const
|
|||
{int ta = this->tabNoeud.Taille(); // nb de noeud
|
||||
switch (ta)
|
||||
{ case 1 : // cas d'une frontière point, on simplifie
|
||||
if (this->tabNoeud(1) == a.tabNoeud(1)) {return true;} else {return false;}
|
||||
if (this->tabNoeud(1) == a.tabNoeud(1)) {return true;} else {return false;}
|
||||
break;
|
||||
case 2 : // cas où la frontière est à 2 noeuds uniquement
|
||||
{if (this->tabNoeud(1) == a.tabNoeud(1))
|
||||
|
|
@ -102,84 +102,84 @@ bool ElFrontiere::operator == ( const ElFrontiere& a) const
|
|||
break;
|
||||
}
|
||||
default : // les autres cas
|
||||
{// récup de l'élément géométrique
|
||||
const ElemGeomC0 & elemgeom = this->ElementGeometrique();
|
||||
const Tableau <int> & ind = elemgeom.Ind(); // récup du tableau des tranches
|
||||
int nb_tranche = ind.Taille(); // le nombre d'intervalle de numéros de noeuds constituant la numérotation
|
||||
// vérification que la taille de toutes les tranches est au moins supérieure à 1
|
||||
#ifdef MISE_AU_POINT
|
||||
if (nb_tranche == 0)
|
||||
{cout << "\n *** erreur, pas de tranche de nb de noeud definie "
|
||||
<< "\n ElFrontiere::MemeNoeud(... " << endl;
|
||||
Sortie(1);
|
||||
};
|
||||
for (int i1=1;i1<=nb_tranche;i1++)
|
||||
if (ind(i1) < 1)
|
||||
{cout << "\n *** erreur, une tranche de nb de noeud est nulle "
|
||||
<< " tableau ind: " << ind
|
||||
<< "\n ElFrontiere::MemeNoeud(... " << endl;
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
// on balaie chaque intervalle
|
||||
int deb_intervalle = 0; int fin_intervalle = 0; // init
|
||||
for (int iter =1;iter<= nb_tranche;iter++)
|
||||
{ int tranche = ind(iter);
|
||||
deb_intervalle = fin_intervalle+1; // mise à jour des bornes de l'intervalle de scrutation
|
||||
fin_intervalle += tranche; // " "
|
||||
// on commence par chercher un premier noeud identique dans l'intervalle
|
||||
bool res = false;
|
||||
int nd; // indice du cote this
|
||||
Noeud * ptNoeud_a = a.tabNoeud(deb_intervalle);
|
||||
for (nd=deb_intervalle; nd<= fin_intervalle; nd++)
|
||||
{if (this->tabNoeud(nd) == ptNoeud_a)
|
||||
{ res = true; break; };
|
||||
};
|
||||
if (!res) // on arrête de suite si
|
||||
{return false;}; // on n'a pas trouvé de premier noeud !!
|
||||
// s'il n'y a qu'un seule noeud dans la tranche, on a finit cette tranche sinon on continue
|
||||
if (tranche > 1)
|
||||
{ // on regarde dans quel sens il faut tourner
|
||||
int ndplus = nd + 1; if (ndplus > fin_intervalle) ndplus -= tranche;
|
||||
int ndmoins = nd - 1; if (ndmoins < deb_intervalle) ndmoins += tranche;
|
||||
if (this->tabNoeud(ndplus) == a.tabNoeud(deb_intervalle+1))
|
||||
{// on est dans le bon sens en augmentant, et c'est ok pour le 2ième noeud,
|
||||
// continue que s'il y a plus de 2 noeuds dans la tranche
|
||||
if (tranche > 2)
|
||||
{ for (int i=1;i<= (tranche-2);i++)
|
||||
{ ndplus++; if (ndplus > fin_intervalle) ndplus -= tranche;
|
||||
if (this->tabNoeud(ndplus) != a.tabNoeud(deb_intervalle+i+1))
|
||||
return false;
|
||||
};
|
||||
};
|
||||
// sinon ok, on vient de balayer tous les noeuds, on continue
|
||||
}
|
||||
// le sens 1 ne marche pas , on regarde l'autre sens
|
||||
else if (this->tabNoeud(ndmoins) == a.tabNoeud(deb_intervalle+1))
|
||||
{// le bon sens est finalement en diminuant
|
||||
// continue que s'il y a plus de 2 noeuds dans la tranche
|
||||
if (tranche > 2)
|
||||
{ for (int i=1;i<= (tranche-2);i++)
|
||||
{ ndmoins--; if (ndmoins < deb_intervalle) ndmoins += tranche;
|
||||
if (this->tabNoeud(ndmoins) != a.tabNoeud(deb_intervalle+i+1))
|
||||
return false;
|
||||
};
|
||||
};
|
||||
// sinon ok, on vient de balayer tous les noeuds, on continue
|
||||
}
|
||||
else // sinon ne marche pas dans les deux sens
|
||||
{ return false;};
|
||||
};
|
||||
}; // fin de la boucle sur les tranches
|
||||
{// récup de l'élément géométrique
|
||||
const ElemGeomC0 & elemgeom = this->ElementGeometrique();
|
||||
const Tableau <int> & ind = elemgeom.Ind(); // récup du tableau des tranches
|
||||
int nb_tranche = ind.Taille(); // le nombre d'intervalle de numéros de noeuds constituant la numérotation
|
||||
// vérification que la taille de toutes les tranches est au moins supérieure à 1
|
||||
#ifdef MISE_AU_POINT
|
||||
if (nb_tranche == 0)
|
||||
{cout << "\n *** erreur, pas de tranche de nb de noeud definie "
|
||||
<< "\n ElFrontiere::MemeNoeud(... " << endl;
|
||||
Sortie(1);
|
||||
};
|
||||
for (int i1=1;i1<=nb_tranche;i1++)
|
||||
if (ind(i1) < 1)
|
||||
{cout << "\n *** erreur, une tranche de nb de noeud est nulle "
|
||||
<< " tableau ind: " << ind
|
||||
<< "\n ElFrontiere::MemeNoeud(... " << endl;
|
||||
Sortie(1);
|
||||
};
|
||||
#endif
|
||||
// on balaie chaque intervalle
|
||||
int deb_intervalle = 0; int fin_intervalle = 0; // init
|
||||
for (int iter =1;iter<= nb_tranche;iter++)
|
||||
{ int tranche = ind(iter);
|
||||
deb_intervalle = fin_intervalle+1; // mise à jour des bornes de l'intervalle de scrutation
|
||||
fin_intervalle += tranche; // " "
|
||||
// on commence par chercher un premier noeud identique dans l'intervalle
|
||||
bool res = false;
|
||||
int nd; // indice du cote this
|
||||
Noeud * ptNoeud_a = a.tabNoeud(deb_intervalle);
|
||||
for (nd=deb_intervalle; nd<= fin_intervalle; nd++)
|
||||
{if (this->tabNoeud(nd) == ptNoeud_a)
|
||||
{ res = true; break; };
|
||||
};
|
||||
if (!res) // on arrête de suite si
|
||||
{return false;}; // on n'a pas trouvé de premier noeud !!
|
||||
// s'il n'y a qu'un seule noeud dans la tranche, on a finit cette tranche sinon on continue
|
||||
if (tranche > 1)
|
||||
{ // on regarde dans quel sens il faut tourner
|
||||
int ndplus = nd + 1; if (ndplus > fin_intervalle) ndplus -= tranche;
|
||||
int ndmoins = nd - 1; if (ndmoins < deb_intervalle) ndmoins += tranche;
|
||||
if (this->tabNoeud(ndplus) == a.tabNoeud(deb_intervalle+1))
|
||||
{// on est dans le bon sens en augmentant, et c'est ok pour le 2ième noeud,
|
||||
// continue que s'il y a plus de 2 noeuds dans la tranche
|
||||
if (tranche > 2)
|
||||
{ for (int i=1;i<= (tranche-2);i++)
|
||||
{ ndplus++; if (ndplus > fin_intervalle) ndplus -= tranche;
|
||||
if (this->tabNoeud(ndplus) != a.tabNoeud(deb_intervalle+i+1))
|
||||
return false;
|
||||
};
|
||||
};
|
||||
// sinon ok, on vient de balayer tous les noeuds, on continue
|
||||
}
|
||||
// le sens 1 ne marche pas , on regarde l'autre sens
|
||||
else if (this->tabNoeud(ndmoins) == a.tabNoeud(deb_intervalle+1))
|
||||
{// le bon sens est finalement en diminuant
|
||||
// continue que s'il y a plus de 2 noeuds dans la tranche
|
||||
if (tranche > 2)
|
||||
{ for (int i=1;i<= (tranche-2);i++)
|
||||
{ ndmoins--; if (ndmoins < deb_intervalle) ndmoins += tranche;
|
||||
if (this->tabNoeud(ndmoins) != a.tabNoeud(deb_intervalle+i+1))
|
||||
return false;
|
||||
};
|
||||
};
|
||||
// sinon ok, on vient de balayer tous les noeuds, on continue
|
||||
}
|
||||
else // sinon ne marche pas dans les deux sens
|
||||
{ return false;};
|
||||
};
|
||||
}; // fin de la boucle sur les tranches
|
||||
|
||||
}; // fin du cas courant (default du switch)
|
||||
}; // fin du switch sur le nombre de noeuds
|
||||
}
|
||||
else // le type est different et ou le numéro de maillage est différent
|
||||
return false;
|
||||
// si on arrive ici, cela veut dire que toutes les égalités sont bonnes pour un cas autre que
|
||||
// point ou frontière à 2 noeuds
|
||||
return true;
|
||||
// si on arrive ici, cela veut dire que toutes les égalités sont bonnes pour un cas autre que
|
||||
// point ou frontière à 2 noeuds
|
||||
return true;
|
||||
};
|
||||
|
||||
// retourne un element frontiere ayant une orientation opposee
|
||||
|
|
@ -205,6 +205,101 @@ ElFrontiere * ElFrontiere::Oppose() const
|
|||
return pt;
|
||||
};
|
||||
|
||||
// calcul éventuel de la normale à un noeud
|
||||
// ce calcul existe pour les éléments 2D, 1D axi, et aussi pour les éléments 1D
|
||||
// qui possède un repère d'orientation
|
||||
// en retour coor = la normale si coor.Dimension() est = à la dimension de l'espace
|
||||
// si le calcul n'existe pas --> coor.Dimension() = 0
|
||||
// ramène un entier :
|
||||
// == 1 : calcul normal
|
||||
// == 0 : problème de calcul -> coor.Dimension() = 0
|
||||
// == 2 : indique que le calcul n'est pas licite pour le noeud passé en paramètre
|
||||
// mais il n'y a pas d'erreur, c'est seulement que l'élément n'est pas ad hoc pour
|
||||
// calculer la normale à ce noeud là
|
||||
// temps: indique à quel moment on veut le calcul
|
||||
int ElFrontiere::CalculNormale_noeud(Enum_dure temps,const Noeud& noe,Coordonnee& coor)
|
||||
{
|
||||
int retour = 1; // init du retour : on part d'un bon a priori
|
||||
Enum_type_geom enutygeom = Type_geom_front();
|
||||
int dima = ParaGlob::Dimension();
|
||||
// on exclue les cas à pb
|
||||
if ( ((dima == 3) && (!ParaGlob::AxiSymetrie()) && ((enutygeom == LIGNE)||(enutygeom == POINT_G)))
|
||||
|| ((dima == 3) && (ParaGlob::AxiSymetrie()) && (enutygeom == POINT_G))
|
||||
|| ((dima == 2) && (enutygeom == POINT_G))
|
||||
)
|
||||
// on n'a pas d'information particulière pour calculer la normale
|
||||
// donc on ne peut pas calculer
|
||||
{ retour = 2;
|
||||
}
|
||||
else // sinon le calcul est possible
|
||||
{ // on commence par repérer le noeud dans la numérotation locale
|
||||
int nuoe=0;
|
||||
int borne_nb_noeud=tabNoeud.Taille()+1;
|
||||
for (int i=1;i< borne_nb_noeud;i++)
|
||||
{Noeud& noeloc = *tabNoeud(i);
|
||||
if ( (noe.Num_noeud() == noeloc.Num_noeud())
|
||||
&& (noe.Num_Mail() == noeloc.Num_Mail())
|
||||
)
|
||||
{nuoe = i; break;
|
||||
};
|
||||
};
|
||||
// on ne continue que si on a trouvé le noeud
|
||||
if (nuoe != 0)
|
||||
{ ElemGeomC0& elemgeom = ElementGeometrique(); // récup de la géométrie
|
||||
// récup des coordonnées locales du noeuds
|
||||
const Coordonnee& theta_noeud = elemgeom.PtelemRef()(nuoe);
|
||||
// récup de la métrique associée à l'élément
|
||||
Met_abstraite * met = this->Metrique();
|
||||
|
||||
// récup des phi et dphi au noeud
|
||||
const Vecteur & phi = elemgeom.Phi_point(theta_noeud);
|
||||
const Mat_pleine& dphi = elemgeom.Dphi_point(theta_noeud);
|
||||
switch (temps)
|
||||
{case TEMPS_0 :
|
||||
{const BaseB& baseB = met->BaseNat_0(tabNoeud,dphi,phi);
|
||||
coor = Util::ProdVec_coor( baseB.Coordo(1), baseB.Coordo(2));
|
||||
coor.Normer();
|
||||
break;
|
||||
}
|
||||
case TEMPS_t :
|
||||
{const BaseB& baseB = met->BaseNat_t(tabNoeud,dphi,phi);
|
||||
coor = Util::ProdVec_coor( baseB.Coordo(1), baseB.Coordo(2));
|
||||
coor.Normer();
|
||||
break;
|
||||
}
|
||||
case TEMPS_tdt :
|
||||
{const BaseB& baseB = met->BaseNat_tdt(tabNoeud,dphi,phi);
|
||||
coor = Util::ProdVec_coor( baseB.Coordo(1), baseB.Coordo(2));
|
||||
coor.Normer();
|
||||
break;
|
||||
}
|
||||
default :
|
||||
cout << "\nErreur : valeur incorrecte du temps demande = "
|
||||
<< Nom_dure(temps) << " !\n";
|
||||
cout << "\n ElFrontiere::CalculNormale_noeud(Enum_dure temps... \n";
|
||||
retour = 0;
|
||||
Sortie(1);
|
||||
};
|
||||
}
|
||||
else
|
||||
{cout << "\n *** erreur le noeud demande num= "<<noe.Num_noeud()
|
||||
<< " du maillage "<< noe.Num_Mail()
|
||||
<< " ne fait pas parti de l'element de frontiere FrontSegLine "
|
||||
<< "contenant les noeuds: \n";
|
||||
for (int i=1;i< borne_nb_noeud;i++)
|
||||
{Noeud& noeloc = *tabNoeud(i);
|
||||
cout << " num "<< noe.Num_noeud() << " mail " << noeloc.Num_Mail() << ", ";
|
||||
};
|
||||
cout << " on ne peut pas calculer la normale au noeud !!"
|
||||
<< "\n ElFrontiere::CalculNormale_noeud(...";
|
||||
retour = 0;
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
// retour
|
||||
return retour;
|
||||
};
|
||||
|
||||
// effacement de la place memoire des frontieres de l'element frontiere
|
||||
void ElFrontiere::EffaceFrontiere()
|
||||
{ for (int i=1; i<= tabfront.Taille(); i++)
|
||||
|
|
@ -250,8 +345,8 @@ double ElFrontiere::MaxDiagonale_tdt()
|
|||
{ double dist= (tabNoeud(i)->Coord2() - tabNoeud(j)->Coord2()).Norme();
|
||||
maxdiagonale = MaX(maxdiagonale,dist);
|
||||
};
|
||||
return maxdiagonale;
|
||||
};
|
||||
return maxdiagonale;
|
||||
};
|
||||
|
||||
// met à jour la boite d'encombrement
|
||||
void ElFrontiere::AjourBoiteEncombrement()
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue