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)

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

View file

@ -160,6 +160,7 @@ Algori::Algori () : // par defaut
,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge() ,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge()
,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact() ,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact()
,inter_transfer(),inter_transfer2() ,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI()
#endif #endif
//---------- stockage pour la transmission des grandeurs consultables ----- //---------- stockage pour la transmission des grandeurs consultables -----
// ,stock_compteur(GENERIQUE_UNE_GRANDEUR_GLOBALE),val_stock_compteur(NULL) // ,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_charge(),temps_transfert_long_charge(),temps_attente_charge()
,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact() ,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact()
,inter_transfer(),inter_transfer2() ,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI()
#endif #endif
//---------- stockage pour la transmission des grandeurs consultables ----- //---------- 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_transfert_long_contact(algo.temps_transfert_long_contact)
,temps_attente_contact(algo.temps_attente_contact) ,temps_attente_contact(algo.temps_attente_contact)
,inter_transfer(),inter_transfer2() ,inter_transfer(),inter_transfer2()
,buffer_ioBI_MPI(algo.buffer_ioBI_MPI),tailles_buffer_ioBI_MPI(algo.tailles_buffer_ioBI_MPI)
#endif #endif
//---------- stockage pour la transmission des grandeurs consultables ----- //---------- stockage pour la transmission des grandeurs consultables -----

View file

@ -83,6 +83,9 @@
#ifdef UTILISATION_MPI #ifdef UTILISATION_MPI
#include "Distribution_CPU.h" #include "Distribution_CPU.h"
#include "ResRaid_MPI.h" #include "ResRaid_MPI.h"
#include "mpi.h"
#include <boost/mpi.hpp>
namespace mpi = boost::mpi;
#endif #endif
// peut-être à modifier sur linux // peut-être à modifier sur linux
@ -331,6 +334,29 @@ class Algori
DiversStockage* diversStockage,Charge* charge, DiversStockage* diversStockage,Charge* charge,
LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats, LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats,
int inc_voulu=0); 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 // visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée // la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
@ -413,21 +439,22 @@ class Algori
// si ptalgo est non nulle, on a une sortie des temps cpu, spécifique // si ptalgo est non nulle, on a une sortie des temps cpu, spécifique
// à la classe AlgoriCombine passé en paramètre // à la classe AlgoriCombine passé en paramètre
virtual void Ecriture_base_info 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 // 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 // cas des paramètres spécifiques
// écriture des paramètres dans la base info // écriture des paramètres dans la base info
// = 1 : on écrit tout // = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles) // = 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 // lecture des paramètres dans la base info
// = 1 : on récupère tout // = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal // choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible // 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 // création d'un fichier de commande: cas des paramètres spécifiques
virtual void Info_commande_parametres(UtilLecture& entreePrinc) = 0; 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 // 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 // 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;}; streampos Debut_increment() const {return debut_increment;};
#else
MPI_Offset Debut_increment() const {return debut_increment;};
#endif
// ==============VARIABLES PROTEGEES : // ==============VARIABLES PROTEGEES :
#ifdef UTILISATION_MPI #ifdef UTILISATION_MPI
// cas d'un calcul parallèle // cas d'un calcul parallèle
Distribution_CPU distribution_CPU_algo; // gestion de la distribution de charge sur CPU 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 #endif
// 1)----------- protégées: spécifiques à un algo ---------- // 1)----------- protégées: spécifiques à un algo ----------
@ -483,8 +523,12 @@ class Algori
Tableau <ListDeuxString> noms_fichier; Tableau <ListDeuxString> noms_fichier;
Tableau <int > typeFlotExterne; Tableau <int > typeFlotExterne;
UtilLecture* entreePrinc; // sauvegarde pour éviter les passages de paramètres 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 // lors d'un restart
#else
MPI_Offset debut_increment;
#endif
Visualisation visualise; // instance sur les utilitaires de visualisation en vrml Visualisation visualise; // instance sur les utilitaires de visualisation en vrml
Visualisation_maple visualise_maple; // instance sur les utilitaires de visualisation en maple Visualisation_maple visualise_maple; // instance sur les utilitaires de visualisation en maple
Visualisation_geomview visualise_geomview; // instance sur les utilitaires de visualisation en Visualisation_geomview visualise_geomview; // instance sur les utilitaires de visualisation en

View file

@ -59,7 +59,23 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
// soir via via base info // soir via via base info
int lec_ent_info = entreePrinc->Lec_ent_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(); 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 // si l'incrément est positif on se positionne à l'incrément voulu
if (inc_voulu >= 0) if (inc_voulu >= 0)
// lecture différenciée en fonction du cas -> positionnement à l'incrément donné // 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é // 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 particulière à l'algorithme
Lecture_base_info(*entrons,cas); Lecture_base_info(*entrons,cas);
#ifdef UTILISATION_MPI #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 // si calcul on sauvegarde la distribution
distribution_CPU_algo.Lecture_base_info(*entrons,cas); distribution_CPU_algo.Lecture_base_info(*entrons,cas);
#endif #endif
@ -153,9 +182,11 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages,
lesContacts->Lec_base_info_LesContacts(*entrons,*lesMaillages lesContacts->Lec_base_info_LesContacts(*entrons,*lesMaillages
, &LesMaillages::Noeud_LesMaille, &LesMaillages::Element_LesMaille); // lecture des contacts éventuelles , &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 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: // 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 // 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 // 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 // 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 else // sinon cela veut que l'on n'est pas à la fin, on peut donc récupérer la position
debut_increment = entrons->tellg(); 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 // mémorisation du temps de la sauvegarde
temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant(); temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
list_incre_temps_sauvegarder.push_front(Entier_et_Double(inc_voulu,temps_derniere_sauvegarde)); 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 // sauvegarde sur base info
@ -202,75 +234,116 @@ void Algori::Ecriture_base_info
{ {
tempsSauvegarde.Mise_en_route_du_comptage(); // temps cpu tempsSauvegarde.Mise_en_route_du_comptage(); // temps cpu
// récup des flots pour base info // récup des flots pour base info
ofstream * sortons = entreePrinc->Sort_BI();
bool sortie_effectuee = false; bool sortie_effectuee = false;
switch (cas) #ifndef UTILISATION_MPI
{ case 1 : // ------- on sauvegarde tout ------------------------- ofstream * sortons = entreePrinc->Sort_BI();
{ entreePrinc->Enregistrement_position_increment_base_info(0.); #else
// écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos int proc_en_cours = ParaGlob::Monde()->rank();
(*sortons) << "\n==========================================================================" // 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
<< "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0. // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() // 2) seul le proc 0 sort l'entête et les paramètres spécifiques de l'algo
<< " 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 if (proc_en_cours == 0) // première partie dédiée proc 0
|| (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant {// dimensionnement de buffer_ioBI_MPI
{ int taille_buffer_io_MPI = 2; // la partie entête
double temps = pa.Variables_de_temps().TempsCourant(); buffer_ioBI_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action
entreePrinc->Enregistrement_position_increment_base_info(incre); std::ostringstream sort; // définition de sort
// écriture du numéro d'incrément dans le cas d'une sauvegarde partielle std::ostringstream * sortons = &sort;
// écriture du numéro d'incrément #endif
(*sortons) << "\n=========================================================================================" switch (cas)
<< "====================" { case 1 : // ------- on sauvegarde tout -------------------------
<< "\n INCREMENT_DE_CHARGE_: " << incre << " intensite " { entreePrinc->Enregistrement_position_increment_base_info(0.);
<< setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge() // écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos
<< " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() (*sortons) << "\n=========================================================================="
<< " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant() << "===================="
<< "\n=========================================================================================" << "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0.
<< "===================="; << " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant()
// mémorisation du temps de la sauvegarde << " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant()
temps_derniere_sauvegarde=temps; << "\n========================================================================================="
list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde)); << "====================";
sortie_effectuee = true; // mémorisation du temps de la sauvegarde
} temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant();
break; list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde));
} sortie_effectuee = true;
default : break;
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; }
if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0)) case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
cout << "Algori::Ecriture_base_info(....)" { // la sauvegarde est effectuée uniquement pour les incréments demandés
<< " cas= " << cas << endl; // --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde
// dans le cas où un comptage du calcul est en cours on l'arrête // sauf si c'est une demande explicite via les paramètres de contrôle
if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage(); if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde)
if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage(); && (!pa.EtatSortieEtatActuelDansBI()))return;
Sortie(1);
}; 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
// écriture sur le flot de sortie en fonction du "cas" {
// if ((incre % pa.Sauvegarde()) == 0) 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) if (sortie_effectuee)
{ {
// ******* reste lescontacts
Ecriture_base_info(*sortons,cas);
#ifdef UTILISATION_MPI #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 // si calcul on sauvegarde la distribution
distribution_CPU_algo.Ecriture_base_info(*sortons,cas); distribution_CPU_algo.Ecriture_base_info(*sortons,cas);
#endif #endif
lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references
lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references
lesCourbes1D->Ecriture_base_info(*sortons,cas); // Ecriture des courbes1D 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 lesCondlim->Ecriture_base_info(*sortons,cas); // Ecriture des ddl bloques
lesContacts->Ecri_base_info_LesContacts(*sortons); // Ecriture des contacts éventuelles 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 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 !!"; // cout << "\n écriture terminée !!";
}; };
tempsSauvegarde.Arret_du_comptage(); // temps cpu 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 // visualisation intéractive via le standard vrml
// la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée // la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée
// dans les algorithmes dérivées // 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 // éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles // dans les classes filles
void Algori::Ecriture_base_info void Algori::Ecriture_base_info
(ofstream& sort,const int cas) (ostream& sort, int cas)
{switch (cas) {switch (cas)
{ case 1 : // on sauvegarde tout { case 1 : // on sauvegarde tout
{ {
@ -1815,7 +2073,7 @@ void Algori::Ecriture_base_info
//sort << "\n debug algori::ecriture_base_info " //sort << "\n debug algori::ecriture_base_info "
// << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul) // << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul)
// << flush; // << 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 -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul);
sort << "\n mode_debug= " << mode_debug << " "; sort << "\n mode_debug= " << mode_debug << " ";
//--- amortissement cinétique //--- amortissement cinétique
@ -1931,7 +2189,7 @@ void Algori::Ecriture_base_info
// ----- écriture éventuelle des paramètres de l'algorithme et informations particulières // ----- écriture éventuelle des paramètres de l'algorithme et informations particulières
sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul); 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) ; sort << " \n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul) ;
//------- modulation de la précision d'équilibre --- //------- modulation de la précision d'équilibre ---
if (modulation_precision != NULL) if (modulation_precision != NULL)
@ -1980,7 +2238,7 @@ void Algori::Ecriture_base_info
// cas donne le niveau de la récupération // cas donne le niveau de la récupération
// = 1 : on récupère tout // = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 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) { switch (cas)
{ case 1 : // on récupère tout { case 1 : // on récupère tout
{ // ----- lecture éventuelle des paramètres de l'algorithme { // ----- lecture éventuelle des paramètres de l'algorithme
@ -1992,7 +2250,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom2; ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul) if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer { // 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é // on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1; ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:") 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;
ent >> nom1; // enfin on passe le nom de l'algo ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture // 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 else
@ -2139,7 +2397,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas)
ent >> nom2; ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul) if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul)
{ // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer { // 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é // on finit la lecture en passant les dernières lignes jusqu'au mot clé
ent >> nom1; ent >> nom1;
while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:") 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;
ent >> nom1; // enfin on passe le nom de l'algo ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture // 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 else

View file

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

View file

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

View file

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

View file

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

View file

@ -421,9 +421,8 @@ void AlgoriCombine::Creation_fct_cst()
// écriture des paramètres dans la base info // écriture des paramètres dans la base info
// = 1 : on écrit tout // = 1 : on écrit tout
// = 2 : on écrit uniquement les données variables (supposées comme telles) // = 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) if (cas == 1)
{//-- tout d'abord les fonctions de gestion d'algo {//-- tout d'abord les fonctions de gestion d'algo
// choix des sous_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(); int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++) for (int i=1;i<=nb_algo;i++)
{ sort << "\n ----->>parametres_sous_algo_specifiques_ "<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul()); { 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()); 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 = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible // 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) if (cas == 1)
{// dimensionnement {// dimensionnement
if (choix) if (choix)
{// cas d'une lecture normale {// cas d'une lecture normale
ifstream * ent = entreePrinc.Ent_BI();
string toto; 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 //-- tout d'abord les fonctions de gestion d'algo
// choix des sous_algo // choix des sous_algo
(*ent) >> toto; // on passe l'entête ent >> toto; // on passe l'entête
if (toto == "aucune") if (toto == "aucune")
{nom_choix_algo = "";choix_algo=NULL;} {nom_choix_algo = "";choix_algo=NULL;}
else else
{nom_choix_algo = toto;}; {nom_choix_algo = toto;};
// gestion de sauvegarde // gestion de sauvegarde
(*ent) >> toto; // on passe l'entête ent >> toto; // on passe l'entête
if (toto == "aucune") if (toto == "aucune")
{nom_gestion_sauvegarde = "";gestion_sauvegarde=NULL;} {nom_gestion_sauvegarde = "";gestion_sauvegarde=NULL;}
else else
{nom_gestion_sauvegarde = toto;}; {nom_gestion_sauvegarde = toto;};
// gestion de sortie à convergence // gestion de sortie à convergence
(*ent) >> toto; // on passe l'entête ent >> toto; // on passe l'entête
if (toto == "aucune") if (toto == "aucune")
{nom_gestion_sortie_a_convergence = "";gestion_sortie_a_convergence=NULL;} {nom_gestion_sortie_a_convergence = "";gestion_sortie_a_convergence=NULL;}
else 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 // 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 // on suit la même logique que celle de Algori::Ecriture_base_info
string nom1,nom2; string nom1,nom2;
(*ent) >> nom1 ; ent >> nom1 ;
if (nom1 == "----->>parametres_sous_algo_specifiques_") if (nom1 == "----->>parametres_sous_algo_specifiques_")
{ // lecture du nom de l'algo { // lecture du nom de l'algo
(*ent) >> nom2; ent >> nom2;
if (Id_nom_TypeCalcul(nom2.c_str()) == tab_algo(i)->TypeDeCalcul()) 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 { // 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é // 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_") while (nom1 != "----->>fin_parametres_sous_algo_specifiques_")
(*ent) >> nom1; ent >> nom1;
(*ent) >> nom1; // enfin on passe le nom de l'algo ent >> nom1; // enfin on passe le nom de l'algo
} }
else else
{ // l'algo ne correspond pas, on passe les informations correspondants { // l'algo ne correspond pas, on passe les informations correspondants
while (nom1 != "----->>fin_parametres_sous_algo_specifiques_:") while (nom1 != "----->>fin_parametres_sous_algo_specifiques_:")
(*ent) >> nom1; ent >> nom1;
(*ent) >> nom1; // enfin on passe le nom de l'algo ent >> nom1; // enfin on passe le nom de l'algo
// on demande à l'agorithme de faire une initialisation sans lecture // 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 else
@ -530,7 +526,7 @@ void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i
Sortie(1); 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 // 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 { // on commence par cumuler tous les temps de calcul
Tableau <Temps_CPU_HZpp> lesTsCpu(18); // init Tableau <Temps_CPU_HZpp> lesTsCpu(18); // init

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -305,12 +305,12 @@ class Charge
// cas donne le niveau de la récupération // cas donne le niveau de la récupération
// = 1 : on récupère tout // = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 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); ,LesFonctions_nD& lesFonctionsnD);
// cas donne le niveau de sauvegarde // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout // = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // = 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 : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -63,7 +63,7 @@ void VariablesTemps::Affiche() const
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 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) // = 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 // 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) {switch (cas)
{ case 1 : // ------- on récupère tout ------------------------- { case 1 : // ------- on récupère tout -------------------------
{ cout << "== lecture des variables temps \n"; { cout << "== lecture des variables temps \n";
@ -82,7 +82,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
} }
default : default :
{cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; {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; << " cas= " << cas << endl;
Sortie(1); Sortie(1);
} }
@ -90,7 +90,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
}; // cas donne le niveau de sauvegarde }; // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout // = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // = 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) {switch (cas)
{ case 1 : // ------- on sauvegarde tout ------------------------- { case 1 : // ------- on sauvegarde tout -------------------------
{ sort << " ****info_temps " ; { sort << " ****info_temps " ;
@ -109,7 +109,7 @@ void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) cons
} }
default : default :
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; { 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; << " cas= " << cas << endl;
Sortie(1); Sortie(1);
} }

View file

@ -116,11 +116,11 @@ class VariablesTemps
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 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) // = 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 // 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 // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout // = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // = 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 : protected :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

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

View file

@ -537,7 +537,7 @@ class Element
// affichage dans la sortie transmise, des variables duales "nom" // affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration // aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables // 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 // 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 // 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) // = 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 // tabMaillageNoeud : contiend les noeuds du maillage de définition de l'élément
virtual void Lecture_base_info 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 // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout // = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // = 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 --------------------------- //-------------- pour modification d'éléments ---------------------------
// définition d'un conteneur pour la définition d'un type d'élément // 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 // = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles) // = 2 : on récupère uniquement les données variables (supposées comme telles)
void Lect_bas_inf_element 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 // cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout // = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // = 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 ---------------- // ---------------- concernant les frontières ----------------

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 // 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 // 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 { /*// lecture du type et vérification
string nom_type; string nom_type;
ent >> nom_type; ent >> nom_type;
@ -485,7 +485,7 @@ void ElFrontiere::Lecture_base_info_ElFrontiere(ifstream& ent)
}; };
// écriture base info // écriture base info
void ElFrontiere::Ecriture_base_info_ElFrontiere(ofstream& sort ) void ElFrontiere::Ecriture_base_info_ElFrontiere(ostream& sort )
{ /*// un identificateur de type { /*// un identificateur de type
sort << "ElFrontiere \n"; sort << "ElFrontiere \n";
// le tableau de noeud associé à l'élément frontière // le tableau de noeud associé à l'élément frontière

View file

@ -231,13 +231,13 @@ class ElFrontiere
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations de la classe générique // ceci concerne uniquement les informations de la classe générique
void Lecture_base_info_ElFrontiere(ifstream& ent); void Lecture_base_info_ElFrontiere(istream& ent);
void Ecriture_base_info_ElFrontiere(ofstream& sort); void Ecriture_base_info_ElFrontiere(ostream& sort);
// ceci concerne uniquement les informations spécifiques des classes dérivées // 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 // 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 // il s'agit donc d'un cas particulier
virtual void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) = 0; virtual void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) = 0;
virtual void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) = 0; virtual void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) = 0;
protected : protected :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

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 // 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 // frontière et changer le pointeur de l'élément finis
// -> utilisation de : Change_elem_frontiere, Change_PtEI // -> 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 { // lecture et vérification du type
string nom_type; string nom_type;
ent >> nom_type; ent >> nom_type;
@ -273,7 +273,7 @@ void Front::Lecture_base_info_front(ifstream& ent)
// écriture base info // écriture base info
// on ne sauvegarde ici que les grandeurs spécifiques à ce niveau // 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 // 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 { // écriture du type
sort << "Front "; sort << "Front ";
// les données // les données

View file

@ -148,12 +148,12 @@ class Front
class Signature_Front { public: int numelem; int numMail;}; class Signature_Front { public: int numelem; int numMail;};
// la lecture s'effectue uniquement au niveau de la signature // la lecture s'effectue uniquement au niveau de la signature
// 1) lecture et retour 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 // 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 // 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 // -> utilisation de : Change_elem_frontiere, Change_PtEI
void Lecture_base_info_front(ifstream& ent); void Lecture_base_info_front(istream& ent);
void Ecriture_base_info_front(ofstream& sort); 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é // 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) void Change_elem_frontiere(const ElFrontiere& el, int num_front)

View file

@ -403,11 +403,11 @@ double FrontSegCub::LongueurApprox()
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> droite >> toto >> theta; 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 << " FrontSC " ;
sort << " dr_tg " << droite << " theta " << theta ; sort << " dr_tg " << droite << " theta " << theta ;
}; };

View file

@ -148,8 +148,8 @@ class FrontSegCub : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -372,11 +372,11 @@ double FrontSegLine::LongueurApprox()
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> droite >> toto >> Mp >> toto >> theta; 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 << " FrontSL " ;
sort << " dr_tg " << droite << " Mp " << Mp << " theta " << theta ; sort << " dr_tg " << droite << " Mp " << Mp << " theta " << theta ;
}; };

View file

@ -151,8 +151,8 @@ class FrontSegLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -476,11 +476,11 @@ double FrontSegQuad::LongueurApprox()
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> droite >> toto >> theta; 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 << " FrontSQ " ;
sort << " dr_tg " << droite << " theta " << theta ; sort << " dr_tg " << droite << " theta " << theta ;
}; };

View file

@ -148,8 +148,8 @@ class FrontSegQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

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

View file

@ -195,8 +195,8 @@ class FrontPointF : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -361,11 +361,11 @@ void FrontQuadCC::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontQCC " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -141,8 +141,8 @@ class FrontQuadCC : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -379,11 +379,11 @@ void FrontQuadLine::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontQL " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -140,8 +140,8 @@ class FrontQuadLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -382,11 +382,11 @@ void FrontQuadQC::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontQC " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -141,8 +141,8 @@ class FrontQuadQC : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -377,11 +377,11 @@ void FrontQuadQuad::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontQQ " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -141,8 +141,8 @@ class FrontQuadQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -367,11 +367,11 @@ void FrontTriaLine::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontTL " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -138,8 +138,8 @@ class FrontTriaLine : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent); void Lecture_base_info_ElFrontiere_pour_projection(istream& ent);
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort); void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort);
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

@ -376,11 +376,11 @@ void FrontTriaQuad::Affiche(Enum_dure temp) const
//----- lecture écriture de restart ----- //----- lecture écriture de restart -----
// ceci concerne uniquement les informations spécifiques // 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; { string toto;
ent >> toto >> toto >> plan >> toto >> theta; 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 << " FrontTQ " ;
sort << " pl_tg " << plan << " theta " << theta ; sort << " pl_tg " << plan << " theta " << theta ;
}; };

View file

@ -139,8 +139,8 @@ class FrontTriaQuad : public ElFrontiere
// ceci concerne uniquement les informations spécifiques // 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 // 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 // il s'agit donc d'un cas particulier
void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ;
void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ;
private : private :
// VARIABLES PROTEGEES : // VARIABLES PROTEGEES :

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

File diff suppressed because one or more lines are too long

View file

@ -158,7 +158,7 @@ class PoutTimo : public ElemMeca
// affichage dans la sortie transmise, des variables duales "nom" // affichage dans la sortie transmise, des variables duales "nom"
// dans le cas ou nom est vide, affichage de "toute" les variables // 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 // Calcul des frontieres de l'element
// creation des elements frontieres et retour du tableau de ces elements // creation des elements frontieres et retour du tableau de ces elements

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -43,7 +43,7 @@
// affichage dans la sortie transmise, des variables duales "nom" // affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration // aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables // 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)) { if ((cas == 1) || (cas == 2))
{ // cas d'une premiere initialisation { // cas d'une premiere initialisation
Tableau<Enum_variable_metrique> tab(5); 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 // liberation des tenseurs intermediaires
LibereTenseur(); 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, TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, 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, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, 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, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, 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, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, 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 = 2 -> premier passage pour de l'explicit
// cas = 11 -> passage autre que le premier pour de l'implicit // cas = 11 -> passage autre que le premier pour de l'implicit
// cas = 12 -> passage autre que le premier pour de l'explicit // 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, Tableau <TenseurHH *>& tabSigHH,Tableau <TenseurBB *> & tabEpsBB,
int nbint,int cas); int nbint,int cas);
// utilitaires de VarDualSort // utilitaires de VarDualSort
// affiche en fonction d'indic les differentes variables et appel // affiche en fonction d'indic les differentes variables et appel
// AffDefContiD en fonction de la dimension i // 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& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig, Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic); int indic);
// cas 1D // 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& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig, Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic); int indic);
// cas 2D // 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& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig, Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic); int indic);
// cas 3D // 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& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH, TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB, TenseurHB& epsHB,TenseurHB& sigHB,

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -122,7 +122,7 @@ class Hexa : public HexaMemb
// affichage dans la sortie transmise, des variables duales "nom" // affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration // aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables // 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 // 2) derivant des virtuelles
// 3) methodes propres a l'element // 3) methodes propres a l'element

View file

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

View file

@ -119,7 +119,7 @@ class HexaLMemb : public HexaMemb
// affichage dans la sortie transmise, des variables duales "nom" // affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration // aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables // 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 // 2) derivant des virtuelles
// 3) methodes propres a l'element // 3) methodes propres a l'element

View file

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

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