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

version intermédiaire 7.033, mise en place d'I/O MPI sur .BI : partie algos , objectif validation de la méthodologie (sortie différée avec bufferisation)

Browse source
This commit is contained in:
Gérard Rio 2024-06-20 15:42:40 +02:00
parent 25e6f768ba
commit 198f4c6927
541 changed files with 3293 additions and 2005 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Algo/AlgoRef/Algori.cc
View file

@ -160,6 +160,7 @@ Algori::Algori () : // par defaut
,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge()
,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact()
,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI()
#endif
//---------- stockage pour la transmission des grandeurs consultables -----
// ,stock_compteur(GENERIQUE_UNE_GRANDEUR_GLOBALE),val_stock_compteur(NULL)
@ -255,6 +256,7 @@ Algori::Algori (EnumTypeCalcul type,const bool avec_typeDeCal
,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge()
,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact()
,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI()
#endif
//---------- stockage pour la transmission des grandeurs consultables -----
@ -458,6 +460,7 @@ Algori::Algori (const Algori& algo) :
,temps_transfert_long_contact(algo.temps_transfert_long_contact)
,temps_attente_contact(algo.temps_attente_contact)
,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(algo.buffer_ioBI_MPI),tailles_buffer_ioBI_MPI(algo.tailles_buffer_ioBI_MPI)
#endif
//---------- stockage pour la transmission des grandeurs consultables -----

56
Algo/AlgoRef/Algori.h
View file

@ -83,6 +83,9 @@
#ifdef UTILISATION_MPI
#include "Distribution_CPU.h"
#include "ResRaid_MPI.h"
#include "mpi.h"
#include <boost/mpi.hpp>
namespace mpi = boost::mpi;
#endif
// peut-être à modifier sur linux
@ -331,7 +334,30 @@ class Algori
DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
int inc_voulu=0);
#ifdef UTILISATION_MPI
// calcul des offsets pour la préparation à l'utilisation de MPI IO
// et transmission au proc i
void Calcul_offsets_IO_MPI
(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);
// écriture des offsets MPI des infos bufferisées propres à Algo ref
void Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(const int cas);
// Lecture des offsets MPI des infos bufferisées
void Lecture_offset_base_info_MPI_IO(const int cas);
// préparation d'un flux sur buffer, pour algo dérivé
// écriture MPI des infos bufferisées
void Ecriture_base_info_MPI_IO(const int cas);
#endif
// visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
@ -413,21 +439,22 @@ class Algori
// si ptalgo est non nulle, on a une sortie des temps cpu, spécifique
// à la classe AlgoriCombine passé en paramètre
virtual void Ecriture_base_info
(ofstream& sort,const int cas);
(ostream& sort,const int cas);
// cas de la lecture spécifique à l'algorithme dans base_info
virtual void Lecture_base_info(ifstream& ent,const int cas);
virtual void Lecture_base_info(istream& ent,const int cas);
// cas des paramètres spécifiques
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
virtual void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) = 0;
virtual void Ecrit_Base_info_Parametre(ostream& sort,const int& cas) = 0;
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
virtual void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) = 0;
virtual void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) = 0;
// création d'un fichier de commande: cas des paramètres spécifiques
virtual void Info_commande_parametres(UtilLecture& entreePrinc) = 0;
@ -449,12 +476,25 @@ class Algori
// récupération de la position lue par l'algo dans le .BI, changé lors d'un restart par exemple
// il s'agit de la sauvegarde par l'algo de la position qu'il a lue en restart
#ifndef UTILISATION_MPI
streampos Debut_increment() const {return debut_increment;};
#else
MPI_Offset Debut_increment() const {return debut_increment;};
#endif
// ==============VARIABLES PROTEGEES :
#ifdef UTILISATION_MPI
// cas d'un calcul parallèle
Distribution_CPU distribution_CPU_algo; // gestion de la distribution de charge sur CPU
// pour les i/o retardées
Tableau <std::string > buffer_ioBI_MPI; // les buffers pour la sortie retardée
std::vector<int> tailles_buffer_ioBI_MPI; // les tailles qui sont transmises par proc 0
std::vector<int> posi_tailles_buffer; // positions pour chaque classe principale
// 1 algo, 2 lesMaillages, 3 lesReferences, 4 lesCourbes1D, 5 lesFonctionsnD
// 6 lesLoisDeComp, 7 diversStockage, 8 charge, 9 lesCondlim,
// 10 lesContacts, 11 resultats
#endif
// 1)----------- protégées: spécifiques à un algo ----------
@ -483,8 +523,12 @@ class Algori
Tableau <ListDeuxString> noms_fichier;
Tableau <int > typeFlotExterne;
UtilLecture* entreePrinc; // sauvegarde pour éviter les passages de paramètres
streampos debut_increment; // sanvegarde de la position du début d'incrément
#ifndef UTILISATION_MPI
streampos debut_increment; // sauvegarde de la position du début d'incrément suivant
// lors d'un restart
#else
MPI_Offset debut_increment;
#endif
Visualisation visualise; // instance sur les utilitaires de visualisation en vrml
Visualisation_maple visualise_maple; // instance sur les utilitaires de visualisation en maple
Visualisation_geomview visualise_geomview; // instance sur les utilitaires de visualisation en

412
Algo/AlgoRef/Algori2.cc
View file

@ -58,8 +58,24 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
{ //il y a deux types d'entrée de donnée soit via un fichier info
// soir via via base info
int lec_ent_info = entreePrinc->Lec_ent_info();
// récup du flot d'entrée
// récup du flot d'entrée
#ifndef UTILISATION_MPI
ifstream * entrons = entreePrinc->Ent_BI();
#else
int proc_en_cours = ParaGlob::Monde()->rank();
// Lecture des offsets MPI des infos bufferisées
Algori::Lecture_offset_base_info_MPI_IO(cas);
// a) ==== lecture du premier buffer propres à Algo ref et def du flux d'entrée associé
MPI_File * ent_MPI = entreePrinc->Ent_BI(); // récup du fichier
{ char * buffer_car = new char [tailles_buffer_ioBI_MPI[0]] ;
MPI_Status status1;
int ierr1 = MPI_File_read_all(*ent_MPI, buffer_car, tailles_buffer_ioBI_MPI[0], MPI_CHAR, &status1);
// on crée le flux sur le tableau de caractères:
istrstream * entrons = new istrstream(buffer_car,tailles_buffer_ioBI_MPI[0]) ;
#endif
// si l'incrément est positif on se positionne à l'incrément voulu
if (inc_voulu >= 0)
// lecture différenciée en fonction du cas -> positionnement à l'incrément donné
@ -135,10 +151,23 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
}
};
// fin du positionnement à l'incrément donné
#ifdef UTILISATION_MPI
}; // fin de la lecture du premier buffer
// b) ==== lecture du deuxième buffer propres à Algo ref et def du flux d'entrée associé
{ char * buffer_car = new char [tailles_buffer_ioBI_MPI[1]] ;
MPI_Status status1;
int ierr1 = MPI_File_read_all(*ent_MPI, buffer_car, tailles_buffer_ioBI_MPI[1], MPI_CHAR, &status1);
// on crée le flux sur le tableau de caractères:
istrstream * entrons = new istrstream(buffer_car,tailles_buffer_ioBI_MPI[1]) ;
#endif
// lecture particulière à l'algorithme
Lecture_base_info(*entrons,cas);
#ifdef UTILISATION_MPI
}; // fin de la lecture du second buffer
ifstream * entrons = NULL; // en MPI on ne doit pas utiliser entrons, on le met donc à NULL
// ce qui permettra de détecter des erreurs éventuelles
// si calcul on sauvegarde la distribution
distribution_CPU_algo.Lecture_base_info(*entrons,cas);
#endif
@ -153,9 +182,11 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
lesContacts->Lec_base_info_LesContacts(*entrons,*lesMaillages
, &LesMaillages::Noeud_LesMaille, &LesMaillages::Element_LesMaille); // lecture des contacts éventuelles
resultats->Lect_result_base_info(*entrons,cas); // lecture des parametres de gestion de la sortie des resultats
// --- on récupère la position du pointeur dans le fichier
// --- on récupère la position du pointeur dans le fichier, utilisé éventuellement ensuite pour l'écriture du prochain incrément
// l'opération n'est pas si simple car on a deux cas:
#ifndef UTILISATION_MPI
// 1) soit on est arrivée à la fin du fichier c-a-d eofbit = 1<<1, // -> 2
// dans ce cas il ne faut pas utiliser tellg() car cela va générer un failbit = 1<<2, // -> 4
// au contraire on va à la fin et ensuite on demande la position
@ -171,14 +202,15 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
}
else // sinon cela veut que l'on n'est pas à la fin, on peut donc récupérer la position
debut_increment = entrons->tellg();
#else
// cas MPI pour l'instant on considère que l'accès à la position est toujours ok (à confirmer !)
MPI_File_get_position(*ent_MPI,&debut_increment);
#endif
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(inc_voulu,temps_derniere_sauvegarde));
{// cas de la lecture de données déjà calculées
// a priori on effectue la lecture des maillages
// il faut penser au contact !!!!!!!
};
};
// sauvegarde sur base info
@ -202,75 +234,116 @@ void Algori::Ecriture_base_info
{
tempsSauvegarde.Mise_en_route_du_comptage(); // temps cpu
// récup des flots pour base info
ofstream * sortons = entreePrinc->Sort_BI();
bool sortie_effectuee = false;
switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ entreePrinc->Enregistrement_position_increment_base_info(0.);
// écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos
(*sortons) << "\n=========================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0.
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde));
sortie_effectuee = true;
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{ // la sauvegarde est effectuée uniquement pour les incréments demandés
// --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde
// sauf si c'est une demande explicite via les paramètres de contrôle
if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde)
&& (!pa.EtatSortieEtatActuelDansBI()))return;
#ifndef UTILISATION_MPI
ofstream * sortons = entreePrinc->Sort_BI();
#else
int proc_en_cours = ParaGlob::Monde()->rank();
// 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie
// qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO
// les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc
// 2) seul le proc 0 sort l'entête et les paramètres spécifiques de l'algo
if ((pa.SauvegardeAutorisee(incre,temps_derniere_sauvegarde,(type_incre==OrdreVisu::DERNIER_INCRE))) // cas courant
|| (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant
{
double temps = pa.Variables_de_temps().TempsCourant();
entreePrinc->Enregistrement_position_increment_base_info(incre);
// écriture du numéro d'incrément dans le cas d'une sauvegarde partielle
// écriture du numéro d'incrément
(*sortons) << "\n========================================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << incre << " intensite "
<< setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge()
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=temps;
list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde));
sortie_effectuee = true;
}
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
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();
Sortie(1);
};
};
// écriture sur le flot de sortie en fonction du "cas"
// if ((incre % pa.Sauvegarde()) == 0)
if (proc_en_cours == 0) // première partie dédiée proc 0
{// dimensionnement de buffer_ioBI_MPI
int taille_buffer_io_MPI = 2; // la partie entête
buffer_ioBI_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action
std::ostringstream sort; // définition de sort
std::ostringstream * sortons = &sort;
#endif
switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ entreePrinc->Enregistrement_position_increment_base_info(0.);
// écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos
(*sortons) << "\n=========================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0.
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde));
sortie_effectuee = true;
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{ // la sauvegarde est effectuée uniquement pour les incréments demandés
// --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde
// sauf si c'est une demande explicite via les paramètres de contrôle
if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde)
&& (!pa.EtatSortieEtatActuelDansBI()))return;
if ((pa.SauvegardeAutorisee(incre,temps_derniere_sauvegarde,(type_incre==OrdreVisu::DERNIER_INCRE))) // cas courant
|| (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant
{
double temps = pa.Variables_de_temps().TempsCourant();
entreePrinc->Enregistrement_position_increment_base_info(incre);
// écriture du numéro d'incrément dans le cas d'une sauvegarde partielle
// écriture du numéro d'incrément
(*sortons) << "\n========================================================================================="
<< "===================="
<< "\n INCREMENT_DE_CHARGE_: " << incre << " intensite "
<< setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge()
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
<< "\n========================================================================================="
<< "====================";
// mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=temps;
list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde));
sortie_effectuee = true;
}
break;
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
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();
Sortie(1);
};
};
#ifdef UTILISATION_MPI
buffer_ioBI_MPI(1) = sort.str(); // on sauvegarde
}; // fin de la sortie de l'entête proc 0
#endif
// écriture sur le flot de sortie en fonction du "cas"
if (sortie_effectuee)
{
// ******* reste lescontacts
Ecriture_base_info(*sortons,cas);
#ifdef UTILISATION_MPI
if (proc_en_cours == 0) // deuxième partie dédiée proc 0
{// redéfinition de sortons sur un nouveau buffer de charactère
std::ostringstream sort; // définition de sort
std::ostringstream * sortons = &sort;
#endif
Ecriture_base_info(*sortons,cas);
#ifdef UTILISATION_MPI
buffer_ioBI_MPI(2) = sort.str(); // on sauvegarde
}; // fin du cas proc 0
// on redéfinit sortons pointant sur un buffer qui doit rester vide
// car en MPI il ne faut pas l'utiliser directement ici
// ********** arrêt transitoire pour tester la technique de sauvegarde et lecture ****
cout << "\n ********** arrêt transitoire pour tester la technique de sauvegarde et lecture **** "
<< "\n Algori::Ecriture_base_info " << endl;
Sortie(1);
std::ostringstream sort; // définition de sort
std::ostringstream * sortons = &sort;
// 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
@ -281,12 +354,197 @@ void Algori::Ecriture_base_info
lesCondlim->Ecriture_base_info(*sortons,cas); // Ecriture des ddl bloques
lesContacts->Ecri_base_info_LesContacts(*sortons); // Ecriture des contacts éventuelles
resultats->Ecri_result_base_info(*sortons,cas); // Ecriture des parametres de gestion de la sortie des resultats
(*sortons) << "\n\n" << endl; // pour passer une ligne et avoir une séparation plus claireflush;
#ifdef UTILISATION_MPI
#ifdef MISE_AU_POINT
// normalement le buffer doit-être vide ! on vérifie
string toto(sort.str());
if (toto.size())
{cout << "\n *** sans doute une erreur, le buffer toto devrait etre vide !! "
<< "\n Algori::Ecriture_base_info(..."
<< "\n toto = " << toto << endl;
Sortie(1);
};
#endif
// si MPI on calcul les offsets pour l'écriture réelle en MPI IO
Calcul_offsets_IO_MPI(cas,lesMaillages,lesReferences,lesCourbes1D
,lesFonctionsnD,lesLoisDeComp,diversStockage
,charge,lesCondlim,lesContacts,resultats
,type_incre,incre);
// on écrit les offsets et des buffers propres à Algo ref
Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(cas);
// on sort sur fichier les buffer
Ecriture_base_info_MPI_IO(cas);
#endif
// cout << "\n écriture terminée !!";
};
tempsSauvegarde.Arret_du_comptage(); // temps cpu
};
#ifdef UTILISATION_MPI
// calcul des offsets pour la préparation à l'utilisation de MPI IO
// et transmission au proc i
void Algori::Calcul_offsets_IO_MPI
(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)
{ // concernant l'algo de ref
tailles_buffer_ioBI_MPI[0] = buffer_ioBI_MPI(1).size();
tailles_buffer_ioBI_MPI[1] = buffer_ioBI_MPI(2).size();
// Tableau <std::string > buffer_ioBI_MPI; // les buffers pour la sortie retardée
// std::vector<int> tailles_buffer_ioBI_MPI; // les tailles qui sont transmises par proc 0
// std::vector<int> posi_tailles_buffer; // positions pour chaque classe principale
// // 1 algo, 2 lesMaillages, 3 lesReferences, 4 lesCourbes1D, 5 lesFonctionsnD
// // 6 lesLoisDeComp, 7 diversStockage, 8 charge, 9 lesCondlim,
// // 10 lesContacts, 11 resultats
};
// écriture des offsets MPI des infos bufferisées
void Algori::Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(const int cas)
{ int proc_en_cours = ParaGlob::Monde()->rank();
// concerne uniquement le proc 0
union entier_caractere // par simplicité
{ int n ; char ch[4]; };
if (proc_en_cours == 0)
{ MPI_File * sort_MPI = entreePrinc->Sort_BI(); // récup du fichier
// === écriture dans flot string de la taille des buffers propres à algo ref
// et de la taille du vector posi_tailles_buffer
// pour avoir une sortie lisible, on crée tout d'abord un buffer string avec les infos
std::ostringstream buf2(std::ios_base::out);
buf2 << "\n offset_base_info_MPI_IO \n";
int taille_tailles_buffer_ioBI_MPI = tailles_buffer_ioBI_MPI.size(); // c'est 2
for (int i=0;i < taille_tailles_buffer_ioBI_MPI;i++)
buf2 << tailles_buffer_ioBI_MPI[i] << " ";
// puis la taille de posi_tailles_buffer
int taille_posi_tailles_buffer = posi_tailles_buffer.size();
buf2 << "\n posi_tailles_buffer \n";
buf2 << taille_posi_tailles_buffer << " ";
// puis posi_tailles_buffer
for (int i=0; i < taille_posi_tailles_buffer ; i++)
buf2 << posi_tailles_buffer[i] << " ";
// le buffer du stream n'est pas pérenne il faut le récupérer
string buf_inter = buf2.str(); // on récupère le buffer
int taille_buf = buf_inter.size();
// 1) ==== écriture de la taille de l'ensemble des offsets propres à Algo ref
// on encapsule pour ré-utiliser la même trame
{
entier_caractere i_c;
i_c.n = taille_buf;
string deb("tout_offset ");
deb.insert(12,*(i_c.ch),4); // ce qui fait 16 caractères qu'on lira avant tout chose
// sortie sur fichier de la taille de buf2
MPI_Status *status; // pour le retour
int ierr = MPI_File_write(*sort_MPI,deb.c_str(),16,MPI_CHAR,status);
};
// 2) ==== écriture de la taille des buffers propres à Algo ref
// et de la taille de posi_tailles_buffer et de posi_tailles_buffer lui-même
{ // sortie sur fichier de buf2
MPI_Status *status; // pour le retour
int ierr = MPI_File_write(*sort_MPI,buf_inter.c_str(),taille_buf,MPI_CHAR,status);
};
// 3) ==== écriture des buffers propres à Algo ref
{ MPI_Status *status; // pour le retour
for (int i=1;i<= 2;i++)
{int ierr = MPI_File_write(*sort_MPI,buffer_ioBI_MPI(i).c_str()
,buffer_ioBI_MPI(i).size(),MPI_CHAR,status);
};
};
};
};
// Lecture des offsets MPI des infos bufferisées
void Algori::Lecture_offset_base_info_MPI_IO(const int cas)
{// on commence par lire la taille du buffer d'offset
MPI_File * ent_MPI = entreePrinc->Ent_BI(); // récup du fichier
// tous les proc lisent
// 1) ==== la taille de l'ensemble des offsets propres à Algo ref
int taille_buf = 0; // init
// on encapsule pour ré-utiliser la même trame
{ char * buffer_car = new char [16] ; // def du tableau de travail
MPI_Status status;
int ierr = MPI_File_read_all(*ent_MPI, buffer_car, 16, MPI_CHAR, &status);
// on crée un flux sur le tableau de caractères:
istrstream * ent_inter = new istrstream(buffer_car,16) ;
// lecture de l'entête
string toto;
(*ent_inter) >> toto;
if (toto != "tout_offset" )
{cout << "\n **** erreur on devait lire : 'tout_offset' "
<< " et on lue "<< toto << " la suite n'est pas possible -> arret !! "
<< "\n Algori::Lecture_offset_base_info_MPI_IO(... "<<endl;
Sortie(1);
};
// on lit la taille de buf2
(*ent_inter) >> toto >> taille_buf;
};
// 2) ==== lecture de la taille des buffers propres à Algo ref
// et de la taille de posi_tailles_buffer et de posi_tailles_buffer lui-même
{ char * buffer_car = new char [taille_buf] ; // def du tableau de travail
MPI_Status status;
int ierr = MPI_File_read_all(*ent_MPI, buffer_car, taille_buf, MPI_CHAR, &status);
// on crée un flux sur le tableau de caractères:
istrstream * ent_inter = new istrstream(buffer_car,taille_buf) ;
// lecture de l'entête
string toto;
(*ent_inter) >> toto;
if (toto != "offset_base_info_MPI_IO" )
{cout << "\n **** erreur on devait lire : 'offset_base_info_MPI_IO' "
<< " et on lue "<< toto << " la suite n'est pas possible -> arret !! "
<< "\n Algori::Lecture_offset_base_info_MPI_IO(... "<<endl;
Sortie(1);
};
// on lit les tailles des buffers
tailles_buffer_ioBI_MPI.resize(2);
for (int i = 0; i < 2; i++)
(*ent_inter) >> tailles_buffer_ioBI_MPI[i];
// puis la taille de posi_tailles_buffer
int taille_posi_tailles_buffer = 0;
(*ent_inter) >> toto;
if (toto != "posi_tailles_buffer" )
{cout << "\n **** erreur on devait lire : 'posi_tailles_buffer' "
<< " et on lue "<< toto << " la suite n'est pas possible -> arret !! "
<< "\n Algori::Lecture_base_info(... "<<endl;
Sortie(1);
};
(*ent_inter) >> taille_posi_tailles_buffer;
posi_tailles_buffer.resize(taille_posi_tailles_buffer);
// puis lecture de posi_tailles_buffer
for (int i=0; i < taille_posi_tailles_buffer ; i++)
(*ent_inter) >> posi_tailles_buffer[i];
};
};
// écriture MPI des infos bufferisées
void Algori::Ecriture_base_info_MPI_IO(const int cas)
{
};
#endif // fin MPI
// visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées
@ -1803,7 +2061,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L
// éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles
void Algori::Ecriture_base_info
(ofstream& sort,const int cas)
(ostream& sort, int cas)
{switch (cas)
{ case 1 : // on sauvegarde tout
{
@ -1815,7 +2073,7 @@ void Algori::Ecriture_base_info
//sort << "\n debug algori::ecriture_base_info "
// << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul)
// << flush;
Ecrit_Base_info_Parametre(*entreePrinc,cas);
Ecrit_Base_info_Parametre(sort,cas);
sort << "\n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
sort << "\n mode_debug= " << mode_debug << " ";
//--- amortissement cinétique
@ -1931,7 +2189,7 @@ void Algori::Ecriture_base_info
// ----- écriture éventuelle des paramètres de l'algorithme et informations particulières
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
Ecrit_Base_info_Parametre(*entreePrinc,cas);
Ecrit_Base_info_Parametre(sort,cas);
sort << " \n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul) ;
//------- modulation de la précision d'équilibre ---
if (modulation_precision != NULL)
@ -1980,7 +2238,7 @@ void Algori::Ecriture_base_info
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Algori::Lecture_base_info(ifstream& ent,const int cas)
void Algori::Lecture_base_info(istream& ent,int cas)
{ switch (cas)
{ case 1 : // on récupère tout
{ // ----- lecture éventuelle des paramètres de l'algorithme
@ -1992,7 +2250,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer
Lecture_Base_info_Parametre(*entreePrinc,cas,true);
Lecture_Base_info_Parametre(ent,cas,true);
// on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
@ -2005,7 +2263,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture
Lecture_Base_info_Parametre(*entreePrinc,cas,false);
Lecture_Base_info_Parametre(ent,cas,false);
};
}
else
@ -2139,7 +2397,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer
Lecture_Base_info_Parametre(*entreePrinc,cas,true);
Lecture_Base_info_Parametre(ent,cas,true);
// on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:")
@ -2152,7 +2410,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture
Lecture_Base_info_Parametre(*entreePrinc,cas,false);
Lecture_Base_info_Parametre(ent,cas,false);
};
}
else

4
Algo/AlgoUtilitaires/AlgoInformations.h
View file

@ -151,12 +151,12 @@ class AlgoInformations : public Algori
// METHODES PROTEGEES :
// --- venant du virtuel ---
// écriture des paramètres dans la base info (ici rien)
void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {};
void Ecrit_Base_info_Parametre(ostream& ,const int& ) {};
// lecture des paramètres dans la base info (ici rien)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool ) {};
void Lecture_Base_info_Parametre(istream& ,const int& ,bool ) {};
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& ) {Algori::Info_com_parametres(*entreePrinc);};
};

8
Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc
View file

@ -425,14 +425,14 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
(cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0);
// visualisation éventuelle au fil du calcul
VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge
VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge
,lesCondLim,lesContacts,resultats,type_incre,(*(inne->incre)-1));
};
};
@ -519,7 +519,7 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail,
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
// ofstream * sort = entreePrinc.Sort_BI();
@ -537,7 +537,7 @@ void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const in
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoUmatAbaqus::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoUmatAbaqus::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{if (choix)
{// cas d'une lecture normale

4
Algo/AlgoUtilitaires/AlgoUmatAbaqus.h
View file

@ -159,14 +159,14 @@ class AlgoUmatAbaqus : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

4
Algo/AlgoUtilitaires/AlgoUtils.h
View file

@ -154,12 +154,12 @@ class AlgoUtils : public Algori
// METHODES PROTEGEES :
// --- venant du virtuel ---
// écriture des paramètres dans la base info (ici rien)
void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {};
void Ecrit_Base_info_Parametre(ostream& ,const int& ) {};
// lecture des paramètres dans la base info (ici rien)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool) {};
void Lecture_Base_info_Parametre(istream& ,const int& ,bool) {};
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& ) {Algori::Info_com_parametres(*entreePrinc);};
};

40
Algo/AlgorithmeCombiner/AlgoriCombine.cc
View file

@ -421,9 +421,8 @@ void AlgoriCombine::Creation_fct_cst()
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrit uniquement les données variables (supposées comme telles)
void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriCombine::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
ofstream& sort = *entreePrinc.Sort_BI();
if (cas == 1)
{//-- tout d'abord les fonctions de gestion d'algo
// choix des sous_algo
@ -446,7 +445,7 @@ void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int
int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++)
{ sort << "\n ----->>parametres_sous_algo_specifiques_ "<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul());
tab_algo(i)->Ecrit_Base_info_Parametre(entreePrinc,cas);
tab_algo(i)->Ecrit_Base_info_Parametre(sort,cas);
sort << "\n ----->>fin_parametres_sous_algo_specifiques_ "<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul());
};
};
@ -458,32 +457,29 @@ void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriCombine::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
if (cas == 1)
{// dimensionnement
if (choix)
{// cas d'une lecture normale
ifstream * ent = entreePrinc.Ent_BI();
string toto;
(*ent) >> toto; // on passe l'entête
ent >> toto; // on passe l'entête
//-- tout d'abord les fonctions de gestion d'algo
// choix des sous_algo
(*ent) >> toto; // on passe l'entête
ent >> toto; // on passe l'entête
if (toto == "aucune")
{nom_choix_algo = "";choix_algo=NULL;}
else
{nom_choix_algo = toto;};
// gestion de sauvegarde
(*ent) >> toto; // on passe l'entête
ent >> toto; // on passe l'entête
if (toto == "aucune")
{nom_gestion_sauvegarde = "";gestion_sauvegarde=NULL;}
else
{nom_gestion_sauvegarde = toto;};
// gestion de sortie à convergence
(*ent) >> toto; // on passe l'entête
ent >> toto; // on passe l'entête
if (toto == "aucune")
{nom_gestion_sortie_a_convergence = "";gestion_sortie_a_convergence=NULL;}
else
@ -496,26 +492,26 @@ void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i
// de sous-algo donc il y a une première ligne qui indique de quel sous algo il s'agit
// on suit la même logique que celle de Algori::Ecriture_base_info
string nom1,nom2;
(*ent) >> nom1 ;
ent >> nom1 ;
if (nom1 == "----->>parametres_sous_algo_specifiques_")
{ // lecture du nom de l'algo
(*ent) >> nom2;
ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == tab_algo(i)->TypeDeCalcul())
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer
Lecture_Base_info_Parametre(entreePrinc,cas,true);
Lecture_Base_info_Parametre(ent,cas,true);
// on finit la lecture en passant les dernières lignes jusqu'au mot clé
(*ent) >> nom1;
ent >> nom1;
while (nom1 != "----->>fin_parametres_sous_algo_specifiques_")
(*ent) >> nom1;
(*ent) >> nom1; // enfin on passe le nom de l'algo
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
}
else
{ // l'algo ne correspond pas, on passe les informations correspondants
while (nom1 != "----->>fin_parametres_sous_algo_specifiques_:")
(*ent) >> nom1;
(*ent) >> nom1; // enfin on passe le nom de l'algo
ent >> nom1;
ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture
Lecture_Base_info_Parametre(entreePrinc,cas,false);
Lecture_Base_info_Parametre(ent,cas,false);
};
}
else
@ -530,7 +526,7 @@ void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i
Sortie(1);
};
tab_algo(i)->Lecture_Base_info_Parametre(entreePrinc,cas,choix);
tab_algo(i)->Lecture_Base_info_Parametre(ent,cas,choix);
}
}
};
@ -891,7 +887,7 @@ void AlgoriCombine::Lecture_algo_interne(const bool avec_typeDeCal
// sortie des temps cpu cumulées de tous les algos
void AlgoriCombine::AutreSortieTempsCPU(ofstream& sort,const int ) const
void AlgoriCombine::AutreSortieTempsCPU(ostream& sort,const int ) const
{ // on commence par cumuler tous les temps de calcul
Tableau <Temps_CPU_HZpp> lesTsCpu(18); // init

10
Algo/AlgorithmeCombiner/AlgoriCombine.h
View file

@ -151,7 +151,7 @@ class AlgoriCombine : public Algori
void SchemaXML_Algori(ofstream& ,const Enum_IO_XML ) const ;
// sortie des temps cpu cumulées de tous les algos
void AutreSortieTempsCPU(ofstream& sort,const int cas) const;
void AutreSortieTempsCPU(ostream& sort, int cas) const;
// sortie pour info de la liste des énumérés de tous les sous-algo
list <EnumTypeCalcul> List_Sous_Algo() const;
@ -209,9 +209,9 @@ class AlgoriCombine : public Algori
// // éventuellement est définit de manière spécifique pour chaque algorithme
// // dans les classes filles
// virtual void Ecriture_base_info
// (ofstream& sort,const int cas);
// (ofstream& sort, int cas);
// // cas de la lecture spécifique à l'algorithme dans base_info
// virtual void Lecture_base_info(ifstream& ent,const int cas);
// virtual void Lecture_base_info(ifstream& ent,int cas);
// lecture des paramètres du calcul
void lecture_Parametres(UtilLecture& entreePrinc);
@ -221,14 +221,14 @@ class AlgoriCombine : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

6
Algo/AlgorithmeCombiner/AlgoriCombine2.cc
View file

@ -158,7 +158,7 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -168,8 +168,8 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
tempsInitialisation.Arret_du_comptage(); // temps cpu

25
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc
View file

@ -262,11 +262,8 @@ void AlgoriRungeKutta::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{ // récup du flot
ofstream& sort = *entreePrinc.Sort_BI();
// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
switch (cas)
void AlgoriRungeKutta::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{ switch (cas)
{case 1 : // ------- on sauvegarde tout -------------------------
{
// ecriture des parametres de réglage du pilotage de RK
@ -281,7 +278,7 @@ void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriRungeKutta::Ecrit_Base_info_Parametre(ostream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -295,10 +292,8 @@ void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const
// choix = true : fonctionememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{// récup du flot
ifstream& ent = *entreePrinc.Ent_BI();
string toto;
void AlgoriRungeKutta::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{string toto;
if (choix)
{switch (cas)
{case 1 : // ------- on récupère tout -------------------------
@ -313,7 +308,7 @@ void AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,cons
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriRungeKutta::Lecture_Base_info_Parametre(istream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -1171,7 +1166,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1181,9 +1176,9 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
// ajout d'un conteneur pour les coordonnées à l'itération 0

4
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h
View file

@ -210,14 +210,14 @@ class AlgoriRungeKutta : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

22
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc
View file

@ -462,7 +462,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -472,8 +472,8 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -923,10 +923,8 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{ // récup du flot
ofstream& sort = *entreePrinc.Sort_BI();
// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
void AlgoriDynaExpli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{ // sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
switch (cas)
{case 1 : // ------- on sauvegarde tout -------------------------
{
@ -946,7 +944,7 @@ void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriDynaExpli::Ecrit_Base_info_Parametre(ostream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -960,10 +958,8 @@ void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
// choix = true : fonctionememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{// récup du flot
ifstream& ent = *entreePrinc.Ent_BI();
string toto;
void AlgoriDynaExpli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{string toto;
if (choix)
{switch (cas)
{case 1 : // ------- on récupère tout -------------------------
@ -987,7 +983,7 @@ void AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriDynaExpli::Lecture_Base_info_Parametre(istream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}

4
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h
View file

@ -213,14 +213,14 @@ class AlgoriDynaExpli : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

14
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc
View file

@ -219,9 +219,9 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
(cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0);
@ -229,8 +229,8 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -1011,7 +1011,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1021,8 +1021,8 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
//--fin cas de restart et/ou de sauvegarde--------

44
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc
View file

@ -501,7 +501,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -511,8 +511,8 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
//--fin cas de restart et/ou de sauvegarde--------
@ -1269,7 +1269,7 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1279,8 +1279,8 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -1743,15 +1743,12 @@ void AlgoriDynaExpli_zhai::lecture_Parametres(UtilLecture& entreePrinc)
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{
// ecriture du parametre
*(sort) << "phi_minus= " << paraTypeCalcul(1) << " "
// ecriture du parametre
sort << "phi_minus= " << paraTypeCalcul(1) << " "
<< "grand_phi=" << paraTypeCalcul(2)<< " "
<< "gamma=" << paraTypeCalcul(3)<< " "
<< "beta=" << paraTypeCalcul(4);
@ -1766,33 +1763,30 @@ void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,co
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{ // dimensionnement
paraTypeCalcul.Change_taille(4);
if(choix)
{// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
{string toto;
// lecture du parametre
*(ent) >> toto ;
ent >> toto ;
if (toto != "phi_minus=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : phi_minus= , au lieu de " << toto
<< "\n AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) ;
*(ent) >> toto ;
ent >> paraTypeCalcul(1) ;
ent >> toto ;
if (toto != "grand_phi=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : grand_phi , au lieu de " << toto
<< "\n AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(2) ;
*(ent) >> toto ;
ent >> paraTypeCalcul(2) ;
ent >> toto ;
if (toto != "gamma=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : gamma= , au lieu de " << toto
@ -1800,8 +1794,8 @@ void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,
Sortie(1);
};
// lecture du parametre
*(ent) >> paraTypeCalcul(3);
*(ent) >> toto ;
ent >> paraTypeCalcul(3);
ent >> toto ;
if (toto != "beta=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : beta= , au lieu de " << toto
@ -1809,7 +1803,7 @@ void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,
Sortie(1);
};
// lecture du parametre
*(ent) >> paraTypeCalcul(4);
ent >> paraTypeCalcul(4);
}
else
{ // cas où la lecture est impossible, on attribut les valeurs par défaut

4
Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h
View file

@ -209,12 +209,12 @@ class AlgoriDynaExpli_zhai : public Algori
// lecture des paramètres du calcul
void lecture_Parametres(UtilLecture& entreePrinc);
// écriture des paramètres dans la base info
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);
// gestion et vérification du pas de temps et modif en conséquence si nécessaire

25
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc
View file

@ -495,7 +495,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -505,8 +505,8 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
//--fin cas de restart et/ou de sauvegarde--------
@ -1269,7 +1269,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1279,8 +1279,8 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -1788,14 +1788,12 @@ void Algori_chung_lee::lecture_Parametres(UtilLecture& entreePrinc)
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Algori_chung_lee::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void Algori_chung_lee::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// ecriture du parametre
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{ *(sort) << "beta= " << paraTypeCalcul(1) << " ";
{ sort << "beta= " << paraTypeCalcul(1) << " ";
}
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
};
@ -1806,24 +1804,23 @@ void Algori_chung_lee::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Algori_chung_lee::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void Algori_chung_lee::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{// dimensionnement
paraTypeCalcul.Change_taille(1);
if (choix)
{// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
// lecture du parametre
*(ent) >> toto ;
ent >> toto ;
if (toto != "beta=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : beta= , au lieu de " << toto
<< "\n Algori_chung_lee::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) ;
ent >> paraTypeCalcul(1) ;
}
else
{// cas où la lecture n'est pas possible, attribution des valeurs par défaut

4
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h
View file

@ -210,14 +210,14 @@ class Algori_chung_lee : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);
// gestion et vérification du pas de temps et modif en conséquence si nécessaire

21
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc
View file

@ -348,9 +348,8 @@ void AlgoriRelaxDyna::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{ // récup du flot
ofstream& sort = *entreePrinc.Sort_BI();
// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
switch (cas)
{case 1 : // ------- on sauvegarde tout -------------------------
@ -393,7 +392,7 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
{sort << "\n ponderationGrandeurGlobale_lambda 0 ";}
else
{sort << "\n ponderationGrandeurGlobale_lambda 1 " ;
niveauLambda_grandeurGlobale->Ecriture_base_info(sort,cas,sans_courbe);
niveauLambda_grandeurGlobale->Ecriture_base_info(sort,cas,sans_courbe);
};
// écriture des pondérations éventuelles
@ -421,7 +420,7 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriRelaxDyna::Ecrit_Base_info_Parametre(ostream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -435,10 +434,8 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
// choix = true : fonctionememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{// récup du flot
ifstream& ent = *entreePrinc.Ent_BI();
string toto;
void AlgoriRelaxDyna::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{string toto;
if (choix)
{switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
@ -552,7 +549,7 @@ void AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoriRelaxDyna::Lecture_Base_info_Parametre(istream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -1551,7 +1548,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1561,8 +1558,8 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
// ajout d'un conteneur pour les coordonnées à l'itération 0

4
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h
View file

@ -264,14 +264,14 @@ class AlgoriRelaxDyna : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

29
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc
View file

@ -510,17 +510,15 @@ void AlgoriTchamwa::lecture_Parametres(UtilLecture& entreePrinc)
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrit uniquement les données variables (supposées comme telles)
void AlgoriTchamwa::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriTchamwa::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{
// ecriture du parametre
*(sort) << " phi= " << paraTypeCalcul(1) << " " << "typeCalEqui= " << type_cal_equilibre << " ";
sort << " phi= " << paraTypeCalcul(1) << " " << "typeCalEqui= " << type_cal_equilibre << " ";
if (type_cal_equilibre == 2)
{*(sort) << " CGamma_pourVarPhi " << nom_courbe_CGamma_pourVarPhi;
{sort << " CGamma_pourVarPhi " << nom_courbe_CGamma_pourVarPhi;
};
};
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
@ -532,42 +530,41 @@ void AlgoriTchamwa::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriTchamwa::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriTchamwa::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{// dimensionnement
paraTypeCalcul.Change_taille(1);
if (choix)
{// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
// lecture du parametre
*(ent) >> toto ;
ent >> toto ;
if (toto != "phi=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite: tchamwa"
<< "\n on attendait le mot : phi= , au lieu de " << toto
<< "\n AlgoriTchamwa::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) ;
ent >> paraTypeCalcul(1) ;
// lecture du type d'équilibre
*(ent) >> toto ;
ent >> toto ;
if (toto != "typeCalEqui=")
{ cout << "\n erreur en lecture du parametre typeCalEqui: tchamwa"
<< "\n on attendait le mot : typeCalEqui= , au lieu de " << toto
<< "\n AlgoriTchamwa::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> type_cal_equilibre ;
ent >> type_cal_equilibre ;
if (type_cal_equilibre == 2)
{ *(ent) >> toto;
{ ent >> toto;
if (toto != " CGamma_pourVarPhi ")
{ cout << "\n erreur en lecture de la fonction CGamma_pourVarPhi,"
<< " on attendait CGamma_pourVarPhi et on a lue " << toto
<< "\n AlgoriTchamwa::Lecture_base_info_loi(...";
Sortie(1);
};
*(ent) >> nom_courbe_CGamma_pourVarPhi;
ent >> nom_courbe_CGamma_pourVarPhi;
};
}
else
@ -1074,7 +1071,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1085,8 +1082,8 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------

4
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h
View file

@ -238,14 +238,14 @@ class AlgoriTchamwa : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

12
Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc
View file

@ -209,7 +209,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -219,8 +219,8 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -792,7 +792,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -802,8 +802,8 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------

27
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc
View file

@ -609,19 +609,16 @@ void AlgoriNewmark::lecture_Parametres(UtilLecture& entreePrinc)
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriNewmark::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriNewmark::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{ // ecriture des parametres
*(sort) << " beta_et_gamma= " << paraTypeCalcul(1) << " "
<< paraTypeCalcul(2) << " ";
sort << " beta_et_gamma= " << paraTypeCalcul(1) << " "
<< paraTypeCalcul(2) << " ";
// écriture du paramètre hht
*(sort) << " hht= " << paraTypeCalcul(3) << " ";
sort << " hht= " << paraTypeCalcul(3) << " ";
// et le paramètre
*(sort) << " cL_a_chaque_iteration "<< cL_a_chaque_iteration << " ";
sort << " cL_a_chaque_iteration "<< cL_a_chaque_iteration << " ";
};
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
};
@ -632,35 +629,33 @@ void AlgoriNewmark::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriNewmark::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriNewmark::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{// dimensionnement
paraTypeCalcul.Change_taille(3);
if (choix)
{// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
// lecture du premier parametre
*(ent) >> toto ;
ent >> toto ;
if (toto != "beta_et_gamma=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : beta_et_gamma= , au lieu de " << toto
<< "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) >> paraTypeCalcul(2);
ent >> paraTypeCalcul(1) >> paraTypeCalcul(2);
// idem pour le paramètre hht
*(ent) >> toto >> paraTypeCalcul(3);
ent >> toto >> paraTypeCalcul(3);
// lecture de cL_a_chaque_iteration
*(ent) >> toto ;
ent >> toto ;
if (toto != "cL_a_chaque_iteration")
{ cout << "\n erreur en lecture du parametre cL_a_chaque_iteration"
<< "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto
<< "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> cL_a_chaque_iteration ;
ent >> cL_a_chaque_iteration ;
}
else
{// cas où la lecture n'est pas possible, attribution des valeurs par défaut

4
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h
View file

@ -236,14 +236,14 @@ class AlgoriNewmark : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

4
Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc
View file

@ -334,7 +334,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -344,7 +344,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
//--fin cas de restart et/ou de sauvegarde--------

25
Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc
View file

@ -456,7 +456,7 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -466,9 +466,9 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
// choix de la matrice de masse, qui est en fait celle qui correspond au ddl Xi
@ -841,11 +841,8 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrit uniquement les données variables (supposées comme telles)
void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{ // récup du flot
ofstream& sort = *entreePrinc.Sort_BI();
// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
switch (cas)
void AlgoristatExpli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{ switch (cas)
{case 1 : // ------- on sauvegarde tout -------------------------
{
// ecriture du type de calcul d'équilibre
@ -864,7 +861,7 @@ void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoristatExpli::Ecrit_Base_info_Parametre(ostream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -878,10 +875,8 @@ void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i
// choix = true : fonctionememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{// récup du flot
ifstream& ent = *entreePrinc.Ent_BI();
string toto;
void AlgoristatExpli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{string toto;
if (choix)
{switch (cas)
{case 1 : // ------- on récupère tout -------------------------
@ -905,7 +900,7 @@ void AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoristatExpli::Lecture_Base_info_Parametre(istream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}

4
Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h
View file

@ -220,14 +220,14 @@ class AlgoristatExpli : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
///**** inexploitable pour l'instant
void Info_commande_parametres(UtilLecture& entreePrinc){};

26
Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc
View file

@ -220,7 +220,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-‡-dire le premier incrÈment
// aprËs s'Ítre positionnÈ au dÈbut du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -230,8 +230,8 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier ‡ la position du restart
// debut_increment a ÈtÈ dÈfinit dans algori (classe mËre)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
@ -608,16 +608,13 @@ void AlgoriFlambLineaire::lecture_Parametres(UtilLecture& entreePrinc)
// Ècriture des paramËtres dans la base info
// = 1 : on Ècrit tout
// = 2 : on Ècrot uniquement les donnÈes variables (supposÈes comme telles)
void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{
// ecriture du parametre
*(sort) << "methode_et_nbDeValeurPropre= " << paraTypeCalcul(1) << " "
<< paraTypeCalcul(2) << " ";
sort << "methode_et_nbDeValeurPropre= " << paraTypeCalcul(1) << " "
<< paraTypeCalcul(2) << " ";
};
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
@ -629,17 +626,14 @@ void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,con
// choix = true : fonctionnememt normal
// choix = false : la mÈthode ne doit pas lire mais initialiser les donnÈes ‡ leurs valeurs par dÈfaut
// car la lecture est impossible
void AlgoriFlambLineaire::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriFlambLineaire::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{// dimensionnement
paraTypeCalcul.Change_taille(2);
if (choix)
{// cas d'une lecture normale
// rÈcup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
{string toto;
// lecture du premier parametre
*(ent) >> toto ;
ent >> toto ;
if (toto != "methode_et_nbDeValeurPropre=")
{ cout << "\n erreur en lecture du paramËtre de l'algorithme explicite "
<< "\n on attendait le mot : methode_et_nbDeValeurPropre= , au lieu de "
@ -647,7 +641,7 @@ void AlgoriFlambLineaire::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,c
<< "\n AlgoriFlambLineaire::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) >> paraTypeCalcul(2);
ent >> paraTypeCalcul(1) >> paraTypeCalcul(2);
}
else
{// cas o˘ la lecture n'est pas possible, attribution des valeurs par dÈfaut

4
Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h
View file

@ -172,14 +172,14 @@ class AlgoriFlambLineaire : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) ;
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas) ;
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) ;
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) ;
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);
};

54
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc
View file

@ -574,14 +574,11 @@ void AlgoriNonDyna::lecture_Parametres(UtilLecture& entreePrinc)
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrit uniquement les données variables (supposées comme telles)
void AlgoriNonDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
void AlgoriNonDyna::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{// ecriture du parametre
*(sort) << "\n acceleration_convergence= " << acceleration_convergence
{ // ecriture du parametre
sort << "\n acceleration_convergence= " << acceleration_convergence
<< " cas_acceleration_convergence= " << cas_acceleration_convergence
<< " nb_vec_cycle= " << nb_vec_cycle
<< " nb_vec_cycle= " << nb_vec_cycle
@ -604,7 +601,7 @@ void AlgoriNonDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriNonDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
void AlgoriNonDyna::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{
if (cas == 1)
{// dimensionnement
@ -614,100 +611,97 @@ void AlgoriNonDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i
<< " en lecture, que l'on effectue "<< flush;
};
// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
// lecture de acceleration_convergence
*(ent) >> toto ;
ent >> toto ;
if (toto != "acceleration_convergence=")
{ cout << "\n erreur en lecture du parametre acceleration_convergence de l'algorithme implicite statique"
<< "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> acceleration_convergence ;
ent >> acceleration_convergence ;
// lecture de cas_acceleration_convergence
*(ent) >> toto ;
ent >> toto ;
if (toto != "cas_acceleration_convergence=")
{ cout << "\n erreur en lecture du parametre cas_acceleration_convergence"
<< "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> acceleration_convergence ;
ent >> acceleration_convergence ;
// lecture de nb_vec_cycle
*(ent) >> toto ;
ent >> toto ;
if (toto != "nb_vec_cycle=")
{ cout << "\n erreur en lecture du parametre nb_vec_cycle"
<< "\n on attendait le mot : nb_vec_cycle= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> nb_vec_cycle ;
ent >> nb_vec_cycle ;
// lecture de deb_newton_modifie
*(ent) >> toto ;
ent >> toto ;
if (toto != "deb_newton_modifie=")
{ cout << "\n erreur en lecture du parametre deb_newton_modifie"
<< "\n on attendait le mot : deb_newton_modifie= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> deb_newton_modifie ;
ent >> deb_newton_modifie ;
// lecture de fin_newton_modifie
*(ent) >> toto ;
ent >> toto ;
if (toto != "fin_newton_modifie=")
{ cout << "\n erreur en lecture du parametre fin_newton_modifie"
<< "\n on attendait le mot : fin_newton_modifie= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> fin_newton_modifie ;
ent >> fin_newton_modifie ;
// lecture de nb_iter_NM
*(ent) >> toto ;
ent >> toto ;
if (toto != "nb_iter_NM=")
{ cout << "\n erreur en lecture du parametre nb_iter_NM"
<< "\n on attendait le mot : nb_iter_NM= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> nb_iter_NM ;
ent >> nb_iter_NM ;
// lecture de deb_raideur_moyenne
*(ent) >> toto ;
ent >> toto ;
if (toto != "deb_raideur_moyenne=")
{ cout << "\n erreur en lecture du parametre deb_raideur_moyenne"
<< "\n on attendait le mot : deb_raideur_moyenne= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> deb_raideur_moyenne ;
ent >> deb_raideur_moyenne ;
// lecture de fin_raideur_moyenne
*(ent) >> toto ;
ent >> toto ;
if (toto != "fin_raideur_moyenne=")
{ cout << "\n erreur en lecture du parametre fin_raideur_moyenne"
<< "\n on attendait le mot : fin_raideur_moyenne= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> fin_raideur_moyenne ;
ent >> fin_raideur_moyenne ;
// lecture de nb_raideur_moyenne
*(ent) >> toto ;
ent >> toto ;
if (toto != "nb_raideur_moyenne=")
{ cout << "\n erreur en lecture du parametre nb_raideur_moyenne"
<< "\n on attendait le mot : nb_raideur_moyenne= , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> nb_raideur_moyenne ;
ent >> nb_raideur_moyenne ;
// lecture de cL_a_chaque_iteration
*(ent) >> toto ;
ent >> toto ;
if (toto != "cL_a_chaque_iteration")
{ cout << "\n erreur en lecture du parametre cL_a_chaque_iteration"
<< "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto
<< "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> cL_a_chaque_iteration ;
ent >> cL_a_chaque_iteration ;
}
else
{// cas où la lecture n'est pas possible, attribution des valeurs par défaut

4
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h
View file

@ -229,14 +229,14 @@ class AlgoriNonDyna : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

10
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc
View file

@ -423,7 +423,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -433,7 +433,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
};
@ -1938,7 +1938,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -1948,8 +1948,8 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
};
}
//--fin cas de restart et/ou de sauvegarde--------
OrdreVisu::EnumTypeIncre type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul

7
Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc
View file

@ -308,7 +308,8 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ int position = 0;
entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -318,8 +319,8 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
}
}
//--fin cas de restart et/ou de sauvegarde--------

4
Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h
View file

@ -156,12 +156,12 @@ class ImpliNonDynaCont : public Algori
private :
// METHODES PROTEGEES :
// écriture des paramètres dans la base info (ici rien)
void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {};
void Ecrit_Base_info_Parametre(ostream& ,const int& ) {};
// lecture des paramètres dans la base info (ici rien)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool ) {};
void Lecture_Base_info_Parametre(istream& ,const int& ,bool ) {};
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc) {Algori::Info_com_parametres(entreePrinc);};

21
Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc
View file

@ -239,11 +239,8 @@ void AlgoBonelli::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{ // récup du flot
ofstream& sort = *entreePrinc.Sort_BI();
// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
switch (cas)
void AlgoBonelli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{ switch (cas)
{case 1 : // ------- on sauvegarde tout -------------------------
{
// ecriture des parametres de l'algorithme
@ -257,7 +254,7 @@ void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int&
}
default :
{// cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoBonelli::Ecrit_Base_info_Parametre(ostream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -271,10 +268,8 @@ void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int&
// choix = true : fonctionememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{// récup du flot
ifstream& ent = *entreePrinc.Ent_BI();
string toto;
void AlgoBonelli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{string toto;
if (choix)
{switch (cas)
{case 1 : // ------- on récupère tout -------------------------
@ -291,7 +286,7 @@ void AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )"
cout << "AlgoBonelli::Lecture_Base_info_Parametre(istream& ,const int& )"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -861,7 +856,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
@ -871,7 +866,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
entreePrinc->Sort_BI_Positionnement_offset(debut_increment);
}
}
//--fin cas de restart et/ou de sauvegarde--------

4
Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h
View file

@ -242,14 +242,14 @@ class AlgoBonelli : public Algori
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas);
void Ecrit_Base_info_Parametre(ostream& sort,const int& cas);
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix);
void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix);
// création d'un fichier de commande: cas des paramètres spécifiques
void Info_commande_parametres(UtilLecture& entreePrinc);

4
Chargement/BlocCharge_T.h
View file

@ -170,7 +170,7 @@ class BlocCharge : public Bloc_particulier
// affichage et definition interactive des commandes
// attribut : donne un attribut éventuel à afficher dans les choix
void Info_commande_BlocCharge(ofstream & sort,string attribut = "_");
void Info_commande_BlocCharge(ostream & sort,string attribut = "_");
// mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur
// en retour indique si l'association est ok
@ -510,7 +510,7 @@ bool BlocCharge<Bloc_particulier>::operator
/// attrib : donne un attribut éventuel à afficher dans les choix
template <class Bloc_particulier>
void BlocCharge<Bloc_particulier>::Info_commande_BlocCharge
(ofstream & sort,string attrib)
(ostream & sort,string attrib)
{ //On va proposer un menu
string rep=" ";
co_charge="_";

8
Chargement/Charge.cc
View file

@ -1133,7 +1133,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon
// lecture base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesCourbes1D& lesCourbes1D
void Charge::Lecture_base_info(istream& entr,const int cas,LesReferences& ,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD)
{switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
@ -1229,7 +1229,7 @@ void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesC
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "Charge::Lecture_base_info(ifstream& entr,const int cas)"
cout << "Charge::Lecture_base_info(istream& entr,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -1239,7 +1239,7 @@ void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesC
// écriture base info
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Charge::Ecriture_base_info(ofstream& sort,const int cas)
void Charge::Ecriture_base_info(ostream& sort,const int cas)
{switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ sort << "\n ****chargement \n" ;
@ -1313,7 +1313,7 @@ void Charge::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "Charge::Ecriture_base_info(ofstream& sort,const int cas)"
cout << "Charge::Ecriture_base_info(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}

4
Chargement/Charge.h
View file

@ -305,12 +305,12 @@ class Charge
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
void Lecture_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
,LesFonctions_nD& lesFonctionsnD);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
void Ecriture_base_info(ostream& sort,const int cas);
private :
// VARIABLES PROTEGEES :

8
Chargement/VariablesTemps.cc
View file

@ -63,7 +63,7 @@ void VariablesTemps::Affiche() const
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// = 3 : on met à jour uniquement les données variables (supposées comme telles)
// dans ce cas il y a modification des grandeurs, mais pas redimentionnement
void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
void VariablesTemps::Lecture_base_info_temps(istream& entr,const int cas)
{switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
{ cout << "== lecture des variables temps \n";
@ -82,7 +82,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
}
default :
{cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "VariablesTemps::Lecture_base_info(ifstream& entr,const int cas)"
cout << "VariablesTemps::Lecture_base_info(istream& entr,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -90,7 +90,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
}; // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) const
void VariablesTemps::Ecriture_base_info_temps(ostream& sort,const int cas) const
{switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ sort << " ****info_temps " ;
@ -109,7 +109,7 @@ void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) cons
}
default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
cout << "VariablesTemps::Ecriture_base_info(ofstream& sort,const int cas)"
cout << "VariablesTemps::Ecriture_base_info(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}

4
Chargement/VariablesTemps.h
View file

@ -116,11 +116,11 @@ class VariablesTemps
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// = 3 : on met à jour uniquement les données variables (supposées comme telles)
// dans ce cas il y a modification des grandeurs, mais pas redimentionnement
void Lecture_base_info_temps(ifstream& ent,const int cas);
void Lecture_base_info_temps(istream& ent, int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info_temps(ofstream& sort,const int cas) const ;
void Ecriture_base_info_temps(ostream& sort,int cas) const ;
protected :
// VARIABLES PROTEGEES :

6
Elements/Element.cc
View file

@ -1487,7 +1487,7 @@ void Element::Info_com_El
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Element::Lect_bas_inf_element
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
{ // le tableau de connection des noeuds
@ -1663,7 +1663,7 @@ void Element::Lect_bas_inf_element
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Element::Ecri_bas_inf_element(ofstream& sort,const int cas)
void Element::Ecri_bas_inf_element(ostream& sort,const int cas)
{ // en fait ici on sauvegarde la même chose dans tous les cas, par contre la sortie
// totale est documentée.
switch (cas)
@ -1718,7 +1718,7 @@ void Element::Ecri_bas_inf_element(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)"
cout << "ElemMeca::Ecriture_bas_inf(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}

10
Elements/Element.h
View file

@ -537,7 +537,7 @@ class Element
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
virtual void AfficheVarDual(ofstream& sort, Tableau<string>& nom) = 0;
virtual void AfficheVarDual(ostream& sort, Tableau<string>& nom) = 0;
// retourne un numero d'ordre d'un point le plus près ou est exprimé la grandeur enum
// par exemple un point d'intégration, mais n'est utilisable qu'avec des méthodes particulières
@ -879,11 +879,11 @@ class Element
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// tabMaillageNoeud : contiend les noeuds du maillage de définition de l'élément
virtual void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) = 0;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud, int cas) = 0;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0;
virtual void Ecriture_base_info(ostream& sort, int cas) = 0;
//-------------- pour modification d'éléments ---------------------------
// définition d'un conteneur pour la définition d'un type d'élément
@ -1103,11 +1103,11 @@ class Element
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lect_bas_inf_element
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecri_bas_inf_element(ofstream& sort,const int cas) ;
void Ecri_bas_inf_element(ostream& sort,const int cas) ;
// ---------------- concernant les frontières ----------------

4
Elements/Geometrie/Frontiere/ElFrontiere.cc
View file

@ -455,7 +455,7 @@ bool ElFrontiere::Projection_normale(const Coordonnee& A, Coordonnee& P)
// pour l'instant on ne sauvegarde rien car ce n'est pas une bonne idée, et cela ne servira a rien
// lecture base info
void ElFrontiere::Lecture_base_info_ElFrontiere(ifstream& ent)
void ElFrontiere::Lecture_base_info_ElFrontiere(istream& ent)
{ /*// lecture du type et vérification
string nom_type;
ent >> nom_type;
@ -485,7 +485,7 @@ void ElFrontiere::Lecture_base_info_ElFrontiere(ifstream& ent)
};
// écriture base info
void ElFrontiere::Ecriture_base_info_ElFrontiere(ofstream& sort )
void ElFrontiere::Ecriture_base_info_ElFrontiere(ostream& sort )
{ /*// un identificateur de type
sort << "ElFrontiere \n";
// le tableau de noeud associé à l'élément frontière

8
Elements/Geometrie/Frontiere/ElFrontiere.h
View file

@ -231,13 +231,13 @@ class ElFrontiere
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations de la classe générique
void Lecture_base_info_ElFrontiere(ifstream& ent);
void Ecriture_base_info_ElFrontiere(ofstream& sort);
void Lecture_base_info_ElFrontiere(istream& ent);
void Ecriture_base_info_ElFrontiere(ostream& sort);
// ceci concerne uniquement les informations spécifiques des classes dérivées
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
virtual void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) = 0;
virtual void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) = 0;
virtual void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) = 0;
virtual void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) = 0;
protected :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Front.cc
View file

@ -250,7 +250,7 @@ bool Front::In_boite_emcombrement_front(const Coordonnee& M,double extra) const
// ici la lecture n'est pas complète il faut ensuite changer l'élément
// frontière et changer le pointeur de l'élément finis
// -> utilisation de : Change_elem_frontiere, Change_PtEI
void Front::Lecture_base_info_front(ifstream& ent)
void Front::Lecture_base_info_front(istream& ent)
{ // lecture et vérification du type
string nom_type;
ent >> nom_type;
@ -273,7 +273,7 @@ void Front::Lecture_base_info_front(ifstream& ent)
// écriture base info
// on ne sauvegarde ici que les grandeurs spécifiques à ce niveau
// concernant les infos relatives à l'élément, la frontière, etc, ce n'est pas traité ici, mais au niveau de la classe LesContats
void Front::Ecriture_base_info_front(ofstream& sort)
void Front::Ecriture_base_info_front(ostream& sort)
{ // écriture du type
sort << "Front ";
// les données

6
Elements/Geometrie/Frontiere/Front.h
View file

@ -148,12 +148,12 @@ class Front
class Signature_Front { public: int numelem; int numMail;};
// la lecture s'effectue uniquement au niveau de la signature
// 1) lecture et retour de la signature
Signature_Front Lecture_base_info_Signature_Front(ifstream& ent);
Signature_Front Lecture_base_info_Signature_Front(istream& ent);
// ici la lecture n'est pas complète il faut ensuite mettre à jour l'élément
// frontière en fonction de son numéro qui est déjà stocké dans l'élément, et le pointeur de l'élément
// -> utilisation de : Change_elem_frontiere, Change_PtEI
void Lecture_base_info_front(ifstream& ent);
void Ecriture_base_info_front(ofstream& sort);
void Lecture_base_info_front(istream& ent);
void Ecriture_base_info_front(ostream& sort);
// changement d'élément frontière, il faut également le numéro de l'élément fini associé
void Change_elem_frontiere(const ElFrontiere& el, int num_front)

4
Elements/Geometrie/Frontiere/Ligne/FrontSegCub.cc
View file

@ -403,11 +403,11 @@ double FrontSegCub::LongueurApprox()
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontSegCub::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontSegCub::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> droite >> toto >> theta;
};
void FrontSegCub::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontSegCub::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontSC " ;
sort << " dr_tg " << droite << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Ligne/FrontSegCub.h
View file

@ -148,8 +148,8 @@ class FrontSegCub : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc
View file

@ -372,11 +372,11 @@ double FrontSegLine::LongueurApprox()
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontSegLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontSegLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> droite >> toto >> Mp >> toto >> theta;
};
void FrontSegLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontSegLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontSL " ;
sort << " dr_tg " << droite << " Mp " << Mp << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Ligne/FrontSegLine.h
View file

@ -151,8 +151,8 @@ class FrontSegLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.cc
View file

@ -476,11 +476,11 @@ double FrontSegQuad::LongueurApprox()
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontSegQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontSegQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> droite >> toto >> theta;
};
void FrontSegQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontSegQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontSQ " ;
sort << " dr_tg " << droite << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.h
View file

@ -148,8 +148,8 @@ class FrontSegQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Point/FrontPointF.cc
View file

@ -101,7 +101,7 @@ Tableau <ElFrontiere*>& FrontPointF::Frontiere()
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto; int test;
ent >> toto >> test ;
if (test)
@ -112,7 +112,7 @@ void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
{ if (T != NULL) delete T;};
};
void FrontPointF::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontPointF::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontPointF " ;
if (T != NULL)
{ sort << " 1 " << *T ;}

4
Elements/Geometrie/Frontiere/Point/FrontPointF.h
View file

@ -195,8 +195,8 @@ class FrontPointF : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontQuadCC.cc
View file

@ -361,11 +361,11 @@ void FrontQuadCC::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontQuadCC::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontQuadCC::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontQuadCC::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontQuadCC::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontQCC " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontQuadCC.h
View file

@ -141,8 +141,8 @@ class FrontQuadCC : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc
View file

@ -379,11 +379,11 @@ void FrontQuadLine::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontQuadLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontQuadLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontQuadLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontQuadLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontQL " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontQuadLine.h
View file

@ -140,8 +140,8 @@ class FrontQuadLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontQuadQC.cc
View file

@ -382,11 +382,11 @@ void FrontQuadQC::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontQuadQC::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontQuadQC::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontQuadQC::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontQuadQC::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontQC " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontQuadQC.h
View file

@ -141,8 +141,8 @@ class FrontQuadQC : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.cc
View file

@ -377,11 +377,11 @@ void FrontQuadQuad::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontQuadQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontQuadQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontQuadQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontQuadQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontQQ " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.h
View file

@ -141,8 +141,8 @@ class FrontQuadQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontTriaLine.cc
View file

@ -367,11 +367,11 @@ void FrontTriaLine::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontTriaLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontTriaLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontTriaLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontTriaLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontTL " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontTriaLine.h
View file

@ -138,8 +138,8 @@ class FrontTriaLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent);
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort);
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent);
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort);
private :
// VARIABLES PROTEGEES :

4
Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.cc
View file

@ -376,11 +376,11 @@ void FrontTriaQuad::Affiche(Enum_dure temp) const
//----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques
void FrontTriaQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent)
void FrontTriaQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent)
{ string toto;
ent >> toto >> toto >> plan >> toto >> theta;
};
void FrontTriaQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort)
void FrontTriaQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort)
{ sort << " FrontTQ " ;
sort << " pl_tg " << plan << " theta " << theta ;
};

4
Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.h
View file

@ -139,8 +139,8 @@ class FrontTriaQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques
// dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière
// il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ;
void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private :
// VARIABLES PROTEGEES :

10
Elements/Mecanique/Biellette/Biel_axi.cc
View file

@ -628,7 +628,7 @@ const DeuxCoordonnees& Biel_axi::Boite_encombre_element(Enum_dure temps)
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Biel_axi::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la biellette
@ -659,7 +659,7 @@ void Biel_axi::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "Biel_axi::Lecture_base_info(ofstream& sort,int cas)"
cout << "Biel_axi::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -669,7 +669,7 @@ void Biel_axi::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Biel_axi::Ecriture_base_info(ofstream& sort,const int cas)
void Biel_axi::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la biellette
@ -692,7 +692,7 @@ void Biel_axi::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "Biel_axi::Ecriture_base_info(ofstream& sort,int cas)"
cout << "Biel_axi::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -863,7 +863,7 @@ Element* Biel_axi::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const B
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void Biel_axi::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void Biel_axi::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bielette (2 noeuds"<<nombre_V.nbi <<" point(s) d'integration) ";

6
Elements/Mecanique/Biellette/Biel_axi.h
View file

@ -203,7 +203,7 @@ class Biel_axi : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -249,11 +249,11 @@ class Biel_axi : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

10
Elements/Mecanique/Biellette/Biel_axiQ.cc
View file

@ -628,7 +628,7 @@ const DeuxCoordonnees& Biel_axiQ::Boite_encombre_element(Enum_dure temps)
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Biel_axiQ::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la biellette
@ -659,7 +659,7 @@ void Biel_axiQ::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "Biel_axiQ::Lecture_base_info(ofstream& sort,int cas)"
cout << "Biel_axiQ::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -669,7 +669,7 @@ void Biel_axiQ::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Biel_axiQ::Ecriture_base_info(ofstream& sort,const int cas)
void Biel_axiQ::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la biellette
@ -692,7 +692,7 @@ void Biel_axiQ::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "Biel_axiQ::Ecriture_base_info(ofstream& sort,int cas)"
cout << "Biel_axiQ::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -862,7 +862,7 @@ Element* Biel_axiQ::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void Biel_axiQ::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void Biel_axiQ::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bielette ("<<nombre_V.nbne<<" noeuds"<<nombre_V.nbi <<" point(s) d'integration) ";

6
Elements/Mecanique/Biellette/Biel_axiQ.h
View file

@ -204,7 +204,7 @@ class Biel_axiQ : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -250,11 +250,11 @@ class Biel_axiQ : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

10
Elements/Mecanique/Biellette/Biellette.cc
View file

@ -599,7 +599,7 @@ const DeuxCoordonnees& Biellette::Boite_encombre_element(Enum_dure temps)
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Biellette::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la biellette
@ -630,7 +630,7 @@ void Biellette::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "Biellette::Lecture_base_info(ofstream& sort,int cas)"
cout << "Biellette::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -640,7 +640,7 @@ void Biellette::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Biellette::Ecriture_base_info(ofstream& sort,const int cas)
void Biellette::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la biellette
@ -664,7 +664,7 @@ void Biellette::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "Biellette::Ecriture_base_info(ofstream& sort,int cas)"
cout << "Biellette::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -851,7 +851,7 @@ Element* Biellette::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void Biellette::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void Biellette::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bielette (2 noeuds 1 point d'integration) ";

6
Elements/Mecanique/Biellette/Biellette.h
View file

@ -200,7 +200,7 @@ class Biellette : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -246,11 +246,11 @@ class Biellette : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

10
Elements/Mecanique/Biellette/BielletteC1.cc
View file

@ -501,7 +501,7 @@ void BielletteC1::ErreurElement(int type,double& errElemRelative
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void BielletteC1::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la BielletteC1
@ -520,7 +520,7 @@ void BielletteC1::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "BielletteC1::Lecture_base_info(ofstream& sort,int cas)"
cout << "BielletteC1::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -530,7 +530,7 @@ void BielletteC1::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void BielletteC1::Ecriture_base_info(ofstream& sort,const int cas)
void BielletteC1::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la BielletteC1
@ -548,7 +548,7 @@ void BielletteC1::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "BielletteC1::Ecriture_base_info(ofstream& sort,int cas)"
cout << "BielletteC1::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -703,7 +703,7 @@ Element* BielletteC1::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, cons
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void BielletteC1::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void BielletteC1::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bielette (2 noeuds 1 point d'integration) ";

6
Elements/Mecanique/Biellette/BielletteC1.h
View file

@ -189,7 +189,7 @@ class BielletteC1 : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -235,11 +235,11 @@ class BielletteC1 : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

10
Elements/Mecanique/Biellette/BielletteQ.cc
View file

@ -562,7 +562,7 @@ void BielletteQ::ErreurElement(int type,double& errElemRelative
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void BielletteQ::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la BielletteQ
@ -593,7 +593,7 @@ void BielletteQ::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "BielletteQ::Lecture_base_info(ofstream& sort,int cas)"
cout << "BielletteQ::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -603,7 +603,7 @@ void BielletteQ::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void BielletteQ::Ecriture_base_info(ofstream& sort,const int cas)
void BielletteQ::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la BielletteQ
@ -627,7 +627,7 @@ void BielletteQ::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "BielletteQ::Ecriture_base_info(ofstream& sort,int cas)"
cout << "BielletteQ::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -818,7 +818,7 @@ Element* BielletteQ::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void BielletteQ::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void BielletteQ::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{ // affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bieletteQ (3 noeuds 2 point d'integration) ";

6
Elements/Mecanique/Biellette/BielletteQ.h
View file

@ -191,7 +191,7 @@ class BielletteQ : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -236,11 +236,11 @@ class BielletteQ : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

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

@ -667,7 +667,7 @@ void PoutSimple1::TversTdt()
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void PoutSimple1::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la poutre
@ -686,7 +686,7 @@ void PoutSimple1::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "Lecture_base_info(ifstream& ent,const Tableau<Noeud "
cout << "Lecture_base_info(istream& ent,const Tableau<Noeud "
<< " *> * tabMaillageNoeud,const int cas) "
<< " cas= " << cas << endl;
Sortie(1);
@ -697,7 +697,7 @@ void PoutSimple1::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas)
void PoutSimple1::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la poutre
@ -715,7 +715,7 @@ void PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas)"
cout << "PoutSimple1::Ecriture_base_info(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}
@ -825,7 +825,7 @@ int PoutSimple1::TestComplet()
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void PoutSimple1::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void PoutSimple1::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element PoutSimple1 (" << nbNoeud << " noeuds "

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

@ -198,7 +198,7 @@ class PoutSimple1 : public PiPoCo
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
//============= lecture écriture dans base info ==========
@ -206,11 +206,11 @@ class PoutSimple1 : public PiPoCo
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// définition du nombre maxi de point d'intégration dans l'épaisseur
inline int Nb_pt_int_epai()

2
Elements/Mecanique/Biellette/PoutTimo.cc
View file

File diff suppressed because one or more lines are too long

2
Elements/Mecanique/Biellette/PoutTimo.h
View file

@ -158,7 +158,7 @@ class PoutTimo : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// Calcul des frontieres de l'element
// creation des elements frontieres et retour du tableau de ces elements

10
Elements/Mecanique/Deformation_gene/Deformation.h
View file

@ -164,17 +164,17 @@ class Deformation
// affichage des infos
virtual void Affiche();
// idem sur un ofstream
virtual void Affiche(ofstream& sort);
// idem sur un ostream
virtual void Affiche(ostream& sort);
//============= lecture écriture dans base info ==========
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
virtual void Lecture_base_info (ifstream& ent,const int cas);
virtual void Lecture_base_info (istream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
virtual void Ecriture_base_info(ofstream& sort,const int cas);
virtual void Ecriture_base_info(ostream& sort,const int cas);
// mise à jour des informations transitoires en définitif, ou l'inverse
virtual void TdtversT() {meti_t = meti_tdt;(*D_BB_t)=(*D_BB_tdt);};
@ -208,7 +208,7 @@ class Deformation
virtual SaveDefResul * New_et_Initialise() {return (new SaveDefResul(*metrique));};
// affichage des donnees particulieres a l'elements
// de matiere traite ( c-a-dire au pt calcule)
virtual void AfficheDataSpecif(ofstream& sort,SaveDefResul * a) const {a->Affiche(sort);};
virtual void AfficheDataSpecif(ostream& sort,SaveDefResul * a) const {a->Affiche(sort);};
// met à jour les données spécifiques du point considéré
void Mise_a_jour_data_specif(Deformation::SaveDefResul* don) {saveDefResul=don;};

8
Elements/Mecanique/Deformation_gene/DeformationSfe1_stockage.cc
View file

@ -90,8 +90,8 @@ void DeformationSfe1::SaveDefResulSfe1::Affiche()
cout << " meti_a_tdt ";meti_a_tdt.Affiche(); cout <<" ";
};
// idem sur un ofstream
void DeformationSfe1::SaveDefResulSfe1::Affiche(ofstream& sort)
// idem sur un ostream
void DeformationSfe1::SaveDefResulSfe1::Affiche(ostream& sort)
{// les variables de la classe mère
this->Deformation::SaveDefResul::Affiche(sort);
// puis les variables propres
@ -103,7 +103,7 @@ void DeformationSfe1::SaveDefResulSfe1::Affiche(ofstream& sort)
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (ifstream& ent,const int cas)
void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (istream& ent,const int cas)
{// lecture de l'entête
string nom;
// lecture des données
@ -139,7 +139,7 @@ void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (ifstream& ent,const i
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(ofstream& sort,const int cas)
void DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(ostream& sort,const int cas)
{// on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail
// les variables de la classe mère
this->Deformation::SaveDefResul::Ecriture_base_info(sort,cas);

8
Elements/Mecanique/Deformation_gene/Deformation_stockage.cc
View file

@ -179,8 +179,8 @@ void Deformation::SaveDefResul::Affiche()
cout << " meti_tdt ";meti_tdt.Affiche(); cout <<" ";
cout << " D_BB_t= ";D_BB_t->Ecriture(cout); cout << " D_BB_tdt= ";D_BB_tdt->Ecriture(cout);
cout <<" ";};
// idem sur un ofstream
void Deformation::SaveDefResul::Affiche(ofstream& sort)
// idem sur un ostream
void Deformation::SaveDefResul::Affiche(ostream& sort)
{sort << "\n meti_00: " << meti_00 << " meti_t " << meti_t
<< " meti_tdt " << meti_tdt <<" ";
sort << " D_BB_t= ";D_BB_t->Ecriture(sort); sort << " D_BB_tdt= ";D_BB_tdt->Ecriture(sort);
@ -190,7 +190,7 @@ void Deformation::SaveDefResul::Affiche(ofstream& sort)
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Deformation::SaveDefResul::Lecture_base_info (ifstream& ent,const int cas)
void Deformation::SaveDefResul::Lecture_base_info (istream& ent,const int cas)
{ // lecture de l'entête
string nom;
// lecture des données
@ -225,7 +225,7 @@ void Deformation::SaveDefResul::Lecture_base_info (ifstream& ent,const int cas)
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Deformation::SaveDefResul::Ecriture_base_info(ofstream& sort,const int cas)
void Deformation::SaveDefResul::Ecriture_base_info(ostream& sort,const int cas)
{ // on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail
switch (cas)
{ case 1 :

8
Elements/Mecanique/ElemMeca.cc
View file

@ -173,7 +173,7 @@ void ElemMeca::StabMembBiel::TversTdt()
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas)
void ElemMeca::StabMembBiel::Lecture_bas_inf(istream& ent,const int cas)
{string toto,nom;
switch (cas)
{ case 1 : // ------- on récupère tout -------------------------
@ -228,7 +228,7 @@ void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas)"
cout << "ElemMeca::StabMembBiel::Lecture_bas_inf(istream& ent,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
@ -239,7 +239,7 @@ void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas)
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void ElemMeca::StabMembBiel::Ecriture_bas_inf(ofstream& sort,const int cas)
void ElemMeca::StabMembBiel::Ecriture_bas_inf(ostream& sort,const int cas)
{switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{ sort << " "<<Nom_StabMembraneBiel(type_stabMembrane);
@ -264,7 +264,7 @@ void ElemMeca::StabMembBiel::Ecriture_bas_inf(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "ElemMeca::StabMembBiel::Ecriture_bas_inf(ofstream& sort,const int cas)"
cout << "ElemMeca::StabMembBiel::Ecriture_bas_inf(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};

18
Elements/Mecanique/ElemMeca.h
View file

@ -757,11 +757,11 @@ class ElemMeca : public Element
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_bas_inf(ifstream& ent,const int cas) ;
void Lecture_bas_inf(istream& ent,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_bas_inf(ofstream& sort,const int cas) ;
void Ecriture_bas_inf(ostream& sort,const int cas) ;
// complète en attribuant les fct nD si besoin, ceci après une lecture
// initiale base_info
void Complete_StabMembBiel(LesFonctions_nD* lesFonctionsnD);
@ -917,33 +917,33 @@ class ElemMeca : public Element
// cas = 2 -> premier passage pour de l'explicit
// cas = 11 -> passage autre que le premier pour de l'implicit
// cas = 12 -> passage autre que le premier pour de l'explicit
void VarDualSort(ofstream& sort, Tableau<string>& nom,int nbint,int cas);
void VarDualSort(ostream& sort, Tableau<string>& nom,int nbint,int cas);
// utilitaires de VarDualSort
// affiche en fonction d'indic les differentes variables et appel
// AffDefContiD en fonction de la dimension i
//
void AffDefCont( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Coordonnee& valPropreEps,Coordonnee& valPropreDeps,Coordonnee& valPropreSig,
double Mises,TenseurBB& epsAlmBB,TenseurBB& epslogBB, int indic);
// cas 1D
void AffDefCont1D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont1D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Coordonnee& valPropreEps,Coordonnee& valPropreDeps,Coordonnee& valPropreSig,
double Mises,TenseurBB& epsAlmBB,TenseurBB& epslogBB,int indic);
// cas 2D
void AffDefCont2D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont2D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Coordonnee& valPropreEps,Coordonnee& valPropreDeps,Coordonnee& valPropreSig,
double Mises,TenseurBB& epsAlmBB,TenseurBB& epslogBB,int indic);
// cas 3D
void AffDefCont3D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont3D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
@ -985,11 +985,11 @@ class ElemMeca : public Element
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_bas_inf
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_bas_inf(ofstream& sort,const int cas) ;
void Ecriture_bas_inf(ostream& sort,const int cas) ;
// --------- utilitaires pour la dynamique
// calcul de la longueur d'arrête de l'élément minimal

10
Elements/Mecanique/ElemMeca2.cc
View file

@ -644,7 +644,7 @@ void ElemMeca::ContraintesEnAbsolues
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void ElemMeca::Lecture_bas_inf
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{ // appel de la routine d'élément
Element::Lect_bas_inf_element(ent,tabMaillageNoeud,cas);
switch (cas)
@ -686,7 +686,7 @@ void ElemMeca::Lecture_bas_inf
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "ElemMeca::Lecture_bas_inf (ifstream& ent,const int cas)"
cout << "ElemMeca::Lecture_bas_inf (istream& ent,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
@ -786,7 +786,7 @@ void ElemMeca::Lecture_bas_inf
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)
void ElemMeca::Ecriture_bas_inf(ostream& sort,const int cas)
{ // appel de la routine d'élément
Element::Ecri_bas_inf_element(sort,cas);
// en fait ici on sauvegarde la même chose dans tous les cas, par contre la sortie
@ -804,7 +804,7 @@ void ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)
{sort << "\n pas_de_stabilisation_transversale ";}
else
{sort << "\n stabilisation_transversale: ";
pt_StabMembBiel->Ecriture_bas_inf(sort,cas);
pt_StabMembBiel->Ecriture_bas_inf(sort,cas);
};
break;
}
@ -813,7 +813,7 @@ void ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)"
cout << "ElemMeca::Ecriture_bas_inf(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};

10
Elements/Mecanique/ElemMeca4.cc
View file

@ -43,7 +43,7 @@
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void ElemMeca::VarDualSort(ofstream& sort, Tableau<string>& nom,int ,int cas)
void ElemMeca::VarDualSort(ostream& sort, Tableau<string>& nom,int ,int cas)
{ if ((cas == 1) || (cas == 2))
{ // cas d'une premiere initialisation
Tableau<Enum_variable_metrique> tab(5);
@ -273,7 +273,7 @@ void ElemMeca::VarDualSort(ofstream& sort, Tableau<string>& nom,int ,int cas)
// liberation des tenseurs intermediaires
LibereTenseur();
};
void ElemMeca::AffDefCont(ofstream& sort,Loi_comp_abstraite::SaveResul * sDon,
void ElemMeca::AffDefCont(ostream& sort,Loi_comp_abstraite::SaveResul * sDon,
TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
@ -299,7 +299,7 @@ void ElemMeca::AffDefCont(ofstream& sort,Loi_comp_abstraite::SaveResul * sDon,
}
}
};
void ElemMeca::AffDefCont1D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void ElemMeca::AffDefCont1D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
@ -376,7 +376,7 @@ void ElemMeca::AffDefCont1D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveD
};
void ElemMeca::AffDefCont2D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void ElemMeca::AffDefCont2D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
@ -477,7 +477,7 @@ void ElemMeca::AffDefCont2D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveD
}
};
void ElemMeca::AffDefCont3D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void ElemMeca::AffDefCont3D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,

10
Elements/Mecanique/ElemMecaGene.h Executable file → Normal file
View file

@ -105,35 +105,35 @@ pour l'instant en essai pour une classe générale au dessus du solide et des fl
// cas = 2 -> premier passage pour de l'explicit
// cas = 11 -> passage autre que le premier pour de l'implicit
// cas = 12 -> passage autre que le premier pour de l'explicit
void VarDualSort(ofstream& sort, Tableau<string>& nom,
void VarDualSort(ostream& sort, Tableau<string>& nom,
Tableau <TenseurHH *>& tabSigHH,Tableau <TenseurBB *> & tabEpsBB,
int nbint,int cas);
// utilitaires de VarDualSort
// affiche en fonction d'indic les differentes variables et appel
// AffDefContiD en fonction de la dimension i
//
void AffDefCont( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 1D
void AffDefCont1D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont1D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 2D
void AffDefCont2D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont2D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 3D
void AffDefCont3D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
void AffDefCont3D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,

10
Elements/Mecanique/ElemPoint/ElemPoint.cc
View file

@ -676,7 +676,7 @@ void ElemPoint::ErreurElement(int type,double& errElemRelative
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void ElemPoint::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{ // tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de la ElemPoint
@ -708,7 +708,7 @@ void ElemPoint::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "ElemPoint::Lecture_base_info(ofstream& sort,int cas)"
cout << "ElemPoint::Lecture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
@ -718,7 +718,7 @@ void ElemPoint::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void ElemPoint::Ecriture_base_info(ofstream& sort,const int cas)
void ElemPoint::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de la ElemPoint
@ -740,7 +740,7 @@ void ElemPoint::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "ElemPoint::Ecriture_base_info(ofstream& sort,int cas)"
cout << "ElemPoint::Ecriture_base_info(ostream& sort,int cas)"
<< " cas= " << cas << endl;
Sortie(1);
};
@ -886,7 +886,7 @@ bool ElemPoint::ContraintesAbsolues(Tableau <Vecteur>& tabSig)
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void ElemPoint::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void ElemPoint::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{// affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element bielette (2 noeuds 1 point d'integration) ";

6
Elements/Mecanique/ElemPoint/ElemPoint.h
View file

@ -184,7 +184,7 @@ class ElemPoint : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// affichage d'info en fonction de ordre
// ordre = "commande" : affichage d'un exemple d'entree pour l'élément
@ -266,11 +266,11 @@ class ElemPoint : public ElemMeca
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas) ;
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas) ;
void Ecriture_base_info(ostream& sort,const int cas) ;
// METHODES VIRTUELLES:
// --------- calculs utils dans le cadre de la recherche du flambement linéaire

6
Elements/Mecanique/ElemPoint/UmatAbaqus.cc
View file

@ -690,7 +690,7 @@ void UmatAbaqus::Transfert_Umat_ptInteg_tdt(PtIntegMecaInterne& ptIntegMeca)
// affichage en fonction d'un niveau
// niveau > 0: données
void UmatAbaqus::Affiche(ofstream& sort,const int niveau)
void UmatAbaqus::Affiche(ostream& sort,const int niveau)
{ sort << "\n *********** info umat ************ ";
sort << "\n sigma_t "; for (int i=0;i<6;i++) sort << "("<<i<<")= " << STRESS[i];
sort << "\n def "; for (int i=0;i<6;i++) sort << "("<<i<<")= " << STRAN[i];
@ -725,7 +725,7 @@ void UmatAbaqus::Affiche(ofstream& sort,const int niveau)
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void UmatAbaqus::Lecture_base_info(ifstream& ent,const int cas)
void UmatAbaqus::Lecture_base_info(istream& ent,const int cas)
{ string toto,nom;
if (cas == 1)
{ ent >> toto;
@ -741,7 +741,7 @@ void UmatAbaqus::Lecture_base_info(ifstream& ent,const int cas)
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void UmatAbaqus::Ecriture_base_info(ofstream& sort,const int cas)
void UmatAbaqus::Ecriture_base_info(ostream& sort,const int cas)
{ if (cas == 1)
{ sort << "\n StructureUmat_Abaqus: "
<< " nom_tube_envoi " << envoi <<" nom_tube_reception= " << reception << " ";

6
Elements/Mecanique/ElemPoint/UmatAbaqus.h
View file

@ -147,17 +147,17 @@ class UmatAbaqus
void Transfert_Umat_ptInteg_tdt(PtIntegMecaInterne& ptIntegMeca);
// affichage en fonction d'un niveau
void Affiche(ofstream& sort,const int niveau);
void Affiche(ostream& sort,const int niveau);
//----- lecture écriture de restart -----
// cas donne le niveau de la récupération
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lecture_base_info(ifstream& ent,const int cas);
void Lecture_base_info(istream& ent,const int cas);
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Ecriture_base_info(ofstream& sort,const int cas);
void Ecriture_base_info(ostream& sort,const int cas);
// --------------------------------------------------------------------------------
// --- conteneur VARIABLES PUBLIQUES --------

2
Elements/Mecanique/Hexaedre/Hexa.cc
View file

@ -207,7 +207,7 @@ Hexa::~Hexa ()
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void Hexa::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void Hexa::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{ // affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element Hexa (hexaedre trilineaire "<<nombre->nbi<<" pt d'integration) ";

2
Elements/Mecanique/Hexaedre/Hexa.h
View file

@ -122,7 +122,7 @@ class Hexa : public HexaMemb
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// 2) derivant des virtuelles
// 3) methodes propres a l'element

2
Elements/Mecanique/Hexaedre/HexaLMemb.cc
View file

@ -215,7 +215,7 @@ Hexa::~Hexa ()
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void Hexa::AfficheVarDual(ofstream& sort, Tableau<string>& nom)
void Hexa::AfficheVarDual(ostream& sort, Tableau<string>& nom)
{ // affichage de l'entête de l'element
sort << "\n******************************************************************";
sort << "\n Element Hexa (hexaedre trilineaire "<<nombre->nbi<<" pt d'integration) ";

2
Elements/Mecanique/Hexaedre/HexaLMemb.h
View file

@ -119,7 +119,7 @@ class HexaLMemb : public HexaMemb
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
void AfficheVarDual(ofstream& sort, Tableau<string>& nom);
void AfficheVarDual(ostream& sort, Tableau<string>& nom);
// 2) derivant des virtuelles
// 3) methodes propres a l'element

8
Elements/Mecanique/Hexaedre/HexaMemb.cc
View file

@ -406,7 +406,7 @@ Mat_pleine * HexaMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse)
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
void HexaMemb::Lecture_base_info
(ifstream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
(istream& ent,const Tableau<Noeud *> * tabMaillageNoeud,const int cas)
{// tout d'abord appel de la lecture de la classe elem_meca
ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas);
// traitement du cas particulier de l'élément
@ -425,7 +425,7 @@ void HexaMemb::Lecture_base_info
}
default :
{ cout << "\nErreur : valeur incorrecte du type de lecture !\n";
cout << "HexaMemb::Lecture_base_info(ifstream& ent,const "
cout << "HexaMemb::Lecture_base_info(istream& ent,const "
<< "Tableau<Noeud *> * tabMaillageNoeud,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
@ -436,7 +436,7 @@ void HexaMemb::Lecture_base_info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void HexaMemb::Ecriture_base_info(ofstream& sort,const int cas)
void HexaMemb::Ecriture_base_info(ostream& sort,const int cas)
{// tout d'abord appel de l'écriture de la classe elem_meca
ElemMeca::Ecriture_bas_inf(sort,cas);
// traitement du cas particulier de l'élément
@ -454,7 +454,7 @@ void HexaMemb::Ecriture_base_info(ofstream& sort,const int cas)
}
default :
{ cout << "\nErreur : valeur incorrecte du type d'écriture !\n";
cout << "HexaMemb::Ecriture_base_info(ofstream& sort,const int cas)"
cout << "HexaMemb::Ecriture_base_info(ostream& sort,const int cas)"
<< " cas= " << cas << endl;
Sortie(1);
}

Some files were not shown because too many files have changed in this diff Show more