rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Lecture/utilLecture2.cc

1166 lines
50 KiB
C++
Raw Normal View History

introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
# include <iostream>
using namespace std; //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#include "UtilLecture.h"
#include "Sortie.h"
#include <fstream>
#include <cstdlib>
#include <iomanip>
#include <algorithm>
#include "ParaGlob.h"
#include <dirent.h> // pour la gestion de l'ouverture de directory
#include <unistd.h> // idem
#include "CharUtil.h"
// ouverture du fichier base_info après le .info dans le cas d'un restart par exemple
// s'il est déjà ouvert on ne fait rien
// a priori le fichier est ouvert en lecture : lecture
// mais il peut également être en écriture : ecriture
void UtilLecture::Ouverture_base_info(string type_entree)
{ char nomm[132];
char*fileName = nomm;
strcpy(fileName, pteurnom);
if (type_entree == "lecture")
// cas d'une lecture
// on regarde si on a déjà une ouverture en écriture si oui on ferme
{ if (sort_BI != NULL)
Fermeture_base_info();
// maintenant on regarde si la lecture est déjà en cours si oui on ne fait rien
// sinon on ouvre
if (ent_BI == NULL)
{ ent_BI = new fstream(strcat(fileName,".BI"), ios::out | ios::in);
if(!(ent_BI->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_base_info() " << endl;
Sortie(1);
};
// cas du fichier de pointeur, traitement presque analogue
strcpy(fileName, pteurnom);
ent_PI = new fstream(strcat(fileName,".PI"), ios::out | ios::in);
if(!(ent_PI->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " le fichier de pointeur ne peut etre lu, on essaie de faire uniquement avec le .BI "
<< endl;
ent_PI = NULL;
};
bool positionPI = false; // pour de la gestion de cas
if (ent_PI!=NULL) // si le fichier n'est pas vide
{ // et on récupère les pointeurs d'incrément
string toto;int nb_position;
// on lit la première ligne
(*ent_PI) >> toto >> nb_position;
// dans le cas ou il n'y a pas d'erreur
// on effectue la lecture des positions si seulement
// le nombre de position actuellement en service est différent
if (ent_PI->rdstate() == 0)
{// si le nombre de position actuelle est non valide, on lit
if (liste_posi_BI.size() != nb_position)
{ // on efface les positions actuelles
liste_posi_BI.clear();
// lecture des positions
for (int i=1;i<= nb_position;i++)
{ Position_BI truc;
(*ent_PI) >> truc;
liste_posi_BI.push_back(truc);
};
};
positionPI = true;
}
}
// si les positions n'ont pas été validé, on essaie de les recréer
if (!positionPI)
// le fichier de pointeur n'est pas exploitable
// on redéfinit par lecture le tableau de pointeur à partir du .BI
{ cout << "\n attention, le fichier de pointeur .PI n'est pas exploitable "
<< " \n on va donc essayer de retrouver les positions des increments "
<< " dans .BI mais ce sera plus long !! " << endl;
if (ent_PI != NULL) {ent_PI->close();ent_PI = NULL;};
// on efface les positions actuelles
liste_posi_BI.clear();
// on se positionne au premier incrément et si c'est ok on continue
int incre = 0; streampos debut_increment(0);
if (Positionnement_base_info(incre))
{ // enregistrement et bouclage
Position_BI truc(debut_increment,incre);
liste_posi_BI.push_back(truc);
while (Increment_suivant_base_info(debut_increment,incre))
{ // dans la fonction il y a l'enregistrement dans la liste
// d'où on ne fait rien ici
};
// maintenant on se repositionne au début du fichier pour le BI
ent_BI->clear();
ent_BI->seekg(ios::beg);
dernier_increment_lu = 0;
// on sauvegarde les positions pour une prochaine utilisation
strcpy(fileName, pteurnom);
sort_PI = new fstream(strcat(fileName,".PI"), ios::out | ios::in);
if(!(sort_PI->is_open()))
// le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre
{ sort_PI = new fstream(fileName, ios::out | ios::ate);
if(!(sort_PI->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_base_info() " << endl;
Sortie(1);
};
};
list<Position_BI>::iterator iter,iter_fin = liste_posi_BI.end();
(*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: "
<< liste_posi_BI.size() << "\n";
for (iter = liste_posi_BI.begin();iter != iter_fin;iter++)
(*sort_PI) << (*iter) << "\n";
(*sort_PI) << endl;
sort_PI->close();sort_PI=NULL;
};
}
}
}
else if (type_entree == "ecriture")
// cas d'une ecriture
// on regarde si on a déjà une ouverture en lecture si oui on ferme
{ if (ent_BI != NULL)
Fermeture_base_info();
// maintenant on regarde si la lecture est déjà en cours si oui on ne fait rien
// sinon on ouvre et on se place à la fin
if (sort_BI == NULL)
{ sort_BI = new fstream(strcat(fileName,".BI"), ios::out | ios::in | ios::ate);
if(!(sort_BI->is_open()))
// le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre
{ sort_BI = new fstream(fileName, ios::out | ios::ate);
if(!(sort_BI->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_base_info() " << endl;
Sortie(1);
}
}
// même traitement pour le fichier de pointeur d'incrément
// qui est cependant systématiquement mis à 0, on écrit du début
strcpy(fileName, pteurnom);
sort_PI = new fstream(strcat(fileName,".PI"), ios::out | ios::in);
if(!(sort_PI->is_open()))
// le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre
{ sort_PI = new fstream(fileName, ios::out | ios::ate);
if(!(sort_PI->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_base_info() " << endl;
Sortie(1);
}
}
}
}
// essai
/* // essai
fstream * toto;
toto = new fstream("toto", ios::out | ios::in );
toto->clear();
(*toto) << "truc \n";(*toto) << "tric";
// positionnement au début du fichier
toto->seekp(0,ios::beg);
string titi;
(*toto) >> titi;
// récup de l'adresse
streampos adresse = toto->tellp();
// ouverture d'un stream en écriture er positionnement
fstream * toutou;
toto->seekp(0,ios::beg);
toto->close ();
toutou = new fstream("toto",ios::out | ios::in | ios::ate);
toutou->seekp(adresse);
// (*toutou) >> titi;
(*toutou) << "\nfin\n";
toutou->close(); */
};
// fermeture du fichier base_info
void UtilLecture::Fermeture_base_info()
{ if (ent_BI != NULL)
{// cas du fichier ouvert en lecture
delete ent_BI;
ent_BI = NULL;
if(ent_PI != NULL) delete ent_PI;
ent_PI = NULL;
}
if (sort_BI != NULL)
{// cas du fichier ouvert en écriture
delete sort_BI;
sort_BI = NULL;
// on sauvegarde le tableau de pointeur d'incrément
sort_PI->seekp( ios::beg);
list<Position_BI>::iterator iter,iter_fin = liste_posi_BI.end();
(*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: "
<< liste_posi_BI.size() << "\n";
for (iter = liste_posi_BI.begin();iter != iter_fin;iter++)
(*sort_PI) << (*iter) << "\n";
(*sort_PI) << endl;
// puisque le fichier base_info est fermé, on suprime la liste de pointeur
// elle sera remise à jour lors de l'ouverture du .BI
list<Position_BI>::iterator iter_debut = liste_posi_BI.begin();
liste_posi_BI.erase(iter_debut,iter_fin);
// fermeture du fichier
delete sort_PI;
sort_PI = NULL;
}
};
//fichier base_info dans lequel sont lus les enregistrements
ifstream * UtilLecture::Ent_BI()
{ if (ent_BI == NULL)
{ // cas ou le fichier n'est pas ouvert on l'ouvre
Ouverture_base_info("lecture");
}
return (ifstream*) ent_BI;
};
// et pour l'écriture
ofstream * UtilLecture::Sort_BI()
{ if (sort_BI == NULL)
{ // cas ou le fichier n'est pas ouvert on l'ouvre
Ouverture_base_info("ecriture");
}
return (ofstream*) sort_BI;
} ;
// positionnement dans le fichier d'entrès au niveau d'un numéro d'incrément
// si l'on ne trouve pas le numéro on renvoi un indicateur à false
bool UtilLecture::Positionnement_base_info(int inc_voulu)
{ streampos debut_increment(0);
// tout d'abord on vérifie que le fichier base_info est disponible en lecture
// sinon on l'ouvre en lecture
if (ent_BI == NULL)
Ouverture_base_info("lecture");
// --- on ne fait pas une recherche en boucle, comme commencé dans les lignes commentées qui suivent
// car on considère que la liste BI doit exister et contenir les info ha doc
// // on regarde si l'on est au début du fichier sinon dans le cas d'une recherche
// // infructueuse à la fin il faudra aussi faire une recherche au début
// bool debut = true;
// if (std::ios::beg != ( ent_BI->tellg())) debut = false;
// on regarde si l'incrément demandé n'a pas déjà été enregistré
Position_BI pos_ent(ios::beg,inc_voulu);
list <Position_BI>::iterator iposi
= find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_ent);
if (iposi != liste_posi_BI.end())
// dans le cas ou l'incrément existe, on se positionne à l'adresse mémorisée
{ent_BI->clear(); // on remet à 0 les bits de contrôle car si lors d'une précédente lecture
// on est par exemple arrivée à la fin du fichier, la fonction seekg ne fonctionnera
// pas !! car le bit de eof est activé
ent_BI->seekg((*iposi).position, ios::beg);
};
// maintenant on lit
string toto; int titi; int inc; bool inc_trouve = false;
// def d'un tableau d'entrée en flot d'entrée pour faire de la lecture non formaté
char * tableau; int longueur = 250;
tableau = new char [longueur] ; // def du tableau intermediaire
istrstream * intar;
// on définit une position intermédiaire dans le fichier pour bien se positionner
// pour l'écriture ensuite éventuelle des incréments
streampos position_inter=0;
// lecture tant que l'on n'a pas atteint la fin du fichier
do
{ // tout d'abord on mémorise l'ancienne position et on récupère la nouvelle
debut_increment = position_inter;
position_inter = ent_BI->tellg();
// si la ligne est la bonne debut_increment sera positionné sur le début
// de la ligne qui contiend des ====
ent_BI->getline(tableau,longueur,'\n'); // lecture d'une ligne dans le fichier
if (strstr(tableau,"INCREMENT_DE_CHARGE_:")!=NULL)
{ // on repositionne le flot au debut du tableau de carractere
// ouverture du flot a la longueur sans blanc
intar = new istrstream(tableau,short(strlen (tableau))) ;
(*intar) >> toto >> inc;
if (inc == inc_voulu)
// ok on a l'incrément voulu
// fin de la préparation de la lecture pour l'incrément
{(*intar) >> toto >> titi
>> toto ;
inc_trouve = true;
}
delete intar;
}
// test pour vérifier l'intégrité du flot
if (ent_BI->rdstate() != 0)
// si l'on est arrivé à la fin du fichier il n'y a rien à faire
// sinon on remet à flot le flot (cas par exemple d'entier au lieu de caractère)!
if (!(ent_BI->eof()))
ent_BI->clear();
}
while ((!(ent_BI->eof()))&& (!inc_trouve));
delete[] tableau;
if (!inc_trouve)
return false;
else
{ // on passe la ligne des ===
(*ent_BI) >> toto;
// on met à jour la variable dernier_increment_lu
dernier_increment_lu = inc_voulu;
return true;
};
};
// positionnement dans le fichier d'entrès au niveau du numéro d'incrément suivant
// si l'on ne trouve pas de numéro on renvoi un indicateur à false
// la méthode renvoie également la position du début de l'incrément
// et le numéro trouvé d'incrément
bool UtilLecture::Increment_suivant_base_info(streampos& debut_increment,int& inc_lu)
{ // tout d'abord on vérifie que le fichier base_info est disponible en lecture
// sinon on l'ouvre en lecture
if (ent_BI == NULL)
Ouverture_base_info("lecture");
// on regarde si dans la liste des incréments enregistrés, la position du suivant
// s'il existe
Position_BI pos_int(ios::beg,dernier_increment_lu);
list <Position_BI>::iterator iposi
= find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_int);
// iposi représente la position du dernier incrément enregistré
if (iposi != liste_posi_BI.end())
// cas ou l'incrément existe, on prend le suivant
{list <Position_BI>::iterator iposa = iposi; // sauvegarde
iposi++;
// on vérifie qu'il existe et dans ce cas on se positionne correctement
if (iposi != liste_posi_BI.end())
ent_BI->seekg((*iposi).position, ios::beg);
else
// sinon on se met à la dernière position
ent_BI->seekg((*iposa).position, ios::beg);
}
else
// si c'était le dernier enregistré on se met à la dernière position
// au cas ou le fichier de pointeur n'est pas complet
ent_BI->seekg(pos_int.position, ios::beg);
// maintenant on lit
string toto; bool inc_trouve = false;
// def d'un tableau d'entrée en flot d'entrée pour faire de la lecture non formaté
char * tableau; int longueur = 250;
tableau = new char [longueur] ; // def du tableau intermediaire
istrstream * intar;
// on définit une position intermédiaire dans le fichier pour bien se positionner
// pour l'écriture ensuite éventuelle des incréments
streampos position_inter=0;
// lecture tant que l'on n'a pas atteint la fin du fichier
do
{ // tout d'abord on mémorise l'ancienne position et on récupère la nouvelle
debut_increment = position_inter;
position_inter = ent_BI->tellg();
// si la ligne est la bonne debut_increment sera positionné sur le début
// de la ligne qui contiend des ====
ent_BI->getline(tableau,longueur,'\n'); // lecture d'une ligne dans le fichier
if (strstr(tableau,"INCREMENT_DE_CHARGE_:")!=NULL)
{ // on repositionne le flot au debut du tableau de carractere
// ouverture du flot a la longueur sans blanc
intar = new istrstream(tableau,short(strlen (tableau))) ;
(*intar) >> toto >> inc_lu;
// le nouvel incrément n'est valide que s'il est différent de l'ancien
if (inc_lu != dernier_increment_lu)
inc_trouve = true;
delete intar;
}
// test pour vérifier l'intégrité du flot
if (ent_BI->rdstate() != 0)
// si l'on est arrivé à la fin du fichier il n'y a rien à faire
// sinon on remet à flot le flot (cas par exemple d'entier au lieu de caractère)!
if (!(ent_BI->eof()))
ent_BI->clear();
}
while ((!(ent_BI->eof()))&& (!inc_trouve));
delete[] tableau;
// dans le cas où on n'a pas trouvé de bon incrément
if (!inc_trouve)
{ inc_lu = -1;
return false;
}
else
{ // on passe la ligne des ===
(*ent_BI) >> toto;
// on enregistre la position dans la liste de position
// on regarde si l'incrément demandé n'a pas déjà été enregistré
Position_BI pos_ent(debut_increment,inc_lu);
list <Position_BI>::iterator iposi_end = liste_posi_BI.end();
list <Position_BI>::iterator iposi
= find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_ent);
if (iposi == liste_posi_BI.end())
{// le nouvel incrément n'existait pas mais
// éventuellement le nouvel incrément peut-être intercalé entre des anciens
// -- on ré-ordonne la liste, qui normalement ne doit avoir que des singletons
liste_posi_BI.sort();
iposi_end = liste_posi_BI.end(); // au cas où
// -- on regarde si effectivement on est intercalé
if ((* liste_posi_BI.begin() < (*iposi) ) && ((*iposi) < (*iposi_end )))
{// on recherche l'encadrement ad hoc
list <Position_BI>::iterator ipopo;
for (ipopo = liste_posi_BI.begin(); ipopo != iposi_end; ipopo++)
if ((* ipopo) > (*iposi))
break;
if (ipopo != liste_posi_BI.end())
{// dans le cas où la position existe déjà on efface le reste de la liste
// qui est maintenant inutile
liste_posi_BI.erase(ipopo,liste_posi_BI.end());
};
};
liste_posi_BI.push_back(pos_ent);
// // on ré-ordonne la liste, qui normalement ne doit avoir que des singletons
// liste_posi_BI.sort(); // normalement ne sert à rien
};
// on met à jour la variable dernier_increment_lu
dernier_increment_lu = inc_lu;
// retour
return true;
};
};
// enregistrement de la position
// normalement correspond à un début d'incrément
void UtilLecture::Enregistrement_position_increment_base_info(int incr)
{ // récup de la position
streampos position_inter=0;
position_inter = sort_BI->tellp();
// on enregistre la position dans la liste de position
// on regarde si l'incrément demandé n'a pas déjà été enregistré
Position_BI pos_ent(position_inter,incr);
list <Position_BI>::iterator iposi
= find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_ent);
if (iposi != liste_posi_BI.end())
{// dans le cas où la position existe déjà on efface le reste de la liste
// qui est maintenant inutile
liste_posi_BI.erase(iposi,liste_posi_BI.end());
};
// on écrit la nouvelle position
liste_posi_BI.push_back(pos_ent);
};
// renvoi tous les incréments actuellements enregistré
list <int> UtilLecture::Liste_increment()
{ // création de la liste de retour
list<int> list_incr;
// on parcourt la liste des positions d'incréments
// et on remplit la liste des numéros d'incréments
list<Position_BI>::iterator iter,iter_fin = liste_posi_BI.end();
for (iter = liste_posi_BI.begin();iter != iter_fin;iter++)
list_incr.push_back((*iter).num_incr);
// retour
return list_incr;
};
// -------------- cas des temps de calcul ----------------
// ouverture du fichier spécifique des temps cpu
void UtilLecture::Ouverture_fichier_temps_cpu()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort__temps_cpu != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort__temps_cpu = new ofstream(strcat(fileName,"_temps.cpu"));
if(!(sort__temps_cpu->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_temps_cpu() " << endl;
Sortie(1);
};
};
// fermeture du fichier des temps cpu
void UtilLecture::Fermeture_fichier_temps_cpu()
{ if (sort__temps_cpu != NULL)
{ delete(sort__temps_cpu);
sort__temps_cpu = NULL;
};
};
// -------------- cas de la visualisation ----------------
// +++ vrml ++++_____________________________________
// ouverture du fichier principal vrml
void UtilLecture::Ouverture_fichier_principal_vrml()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_princ_vrml != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_princ_vrml = new ofstream(strcat(fileName,"_princ.wrl"));
if(!(sort_princ_vrml->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_principal_vrml() " << endl;
Sortie(1);
}
};
// fermeture du fichier principal vrml
void UtilLecture::Fermeture_fichier_principal_vrml()
{ if (sort_princ_vrml != NULL)
{ delete(sort_princ_vrml);
sort_princ_vrml = NULL;
}
};
// ouverture du fichier de légendes vrml
void UtilLecture::Ouverture_fichier_legende_vrml()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_legende_vrml != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_legende_vrml = new ofstream(strcat(fileName,"_legende.wrl"));
if(!(sort_legende_vrml->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_legende_vrml() " << endl;
Sortie(1);
}
};
// fermeture du fichier légendes vrml
void UtilLecture::Fermeture_fichier_legende_vrml()
{ if (sort_legende_vrml != NULL)
{ delete(sort_legende_vrml);
sort_legende_vrml = NULL;
}
};
// +++ maple ++++ ____________________________________________
// ouverture du fichier maple
void UtilLecture::Ouverture_fichier_principal_maple()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_princ_maple != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_princ_maple = new ofstream(strcat(fileName,"_princ.maple"));
if(!(sort_princ_maple->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_principal_maple() " << endl;
Sortie(1);
}
};
// fermeture du fichier principal maple
void UtilLecture::Fermeture_fichier_principal_maple()
{ if (sort_princ_maple != NULL)
{ delete(sort_princ_maple);
sort_princ_maple = NULL;
}
};
// +++ geomview ++++_____________________________________
// ouverture du fichier principal geomview
void UtilLecture::Ouverture_fichier_principal_geomview()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_princ_geomview != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_princ_geomview = new ofstream(strcat(fileName,"_princ.oogl"));
if(!(sort_princ_geomview->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_principal_geomview() " << endl;
Sortie(1);
}
};
// fermeture du fichier principal geomview
void UtilLecture::Fermeture_fichier_principal_geomview()
{ if (sort_princ_geomview != NULL)
{ delete(sort_princ_geomview);
sort_princ_geomview = NULL;
}
};
// ouverture du fichier de légendes geomview
void UtilLecture::Ouverture_fichier_legende_geomview()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_legende_geomview != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_legende_geomview = new ofstream(strcat(fileName,"_legende.oogl"));
if(!(sort_legende_geomview->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_legende_geomview() " << endl;
Sortie(1);
}
};
// fermeture du fichier légendes geomview
void UtilLecture::Fermeture_fichier_legende_geomview()
{ if (sort_legende_geomview != NULL)
{ delete(sort_legende_geomview);
sort_legende_geomview = NULL;
}
};
// +++ Gid ++++_____________________________________
// ouverture du fichier maillage initial Gid
void UtilLecture::Ouverture_fichier_initial_Gid()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_initial_Gid != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_initial_Gid = new ofstream(strcat(fileName,"_Gid.msh"));
if(!(sort_initial_Gid->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_initial_Gid() " << endl;
Sortie(1);
}
};
// fermeture du fichier maillage initial Gid
void UtilLecture::Fermeture_fichier_initial_Gid()
{ if (sort_initial_Gid != NULL)
{ delete(sort_initial_Gid);
sort_initial_Gid = NULL;
}
};
// ouverture du fichier maillage initial Gid
void UtilLecture::Ouverture_fichier_resultat_Gid()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_resultat_Gid != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_resultat_Gid = new ofstream(strcat(fileName,"_Gid.res"));
if(!(sort_resultat_Gid->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_resultat_Gid() " << endl;
Sortie(1);
}
};
// fermeture du fichier maillage initial Gid
void UtilLecture::Fermeture_fichier_resultat_Gid()
{ if (sort_resultat_Gid != NULL)
{ delete(sort_resultat_Gid);
sort_resultat_Gid = NULL;
}
};
// +++ Gmsh ++++_____________________________________
// ouverture du fichier maillage initial Gmsh
void UtilLecture::Ouverture_fichier_initial_Gmsh()
{ // si le fichier est déjà ouvert on ne fait rien
if (sort_initial_Gmsh != NULL) return;
// sinon on ouvre le fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
sort_initial_Gmsh = new ofstream(strcat(fileName,"_Gmsh.msh"));
if(!(sort_initial_Gmsh->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_initial_Gmsh() " << endl;
Sortie(1);
}
};
// fermeture du fichier maillage initial Gmsh
void UtilLecture::Fermeture_fichier_initial_Gmsh()
{ if (sort_initial_Gmsh != NULL)
{ delete(sort_initial_Gmsh);
sort_initial_Gmsh = NULL;
}
};
// création du répertoire contenant tous les fichiers résultats
void UtilLecture::CreationRepertoireResultat()
{ // création du nom
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
// system(strcat(fileName,"_Gmsh")); // fonctionne mais on ne peut pas savoir
// si le répertoire existe déjà, on utilise donc opendir (mais qui n'est pas
// présent partout !!
DIR * ouvre_dir = opendir(strcat(fileName,"_Gmsh"));
if(ouvre_dir == NULL)
{ // la première fois cela veut dire que le répertoire n'existe pas on le crée avec
// un ordre système
// int toto = mkdir(fileName, 775);
char ordre[132];
char* pordre = ordre;
strcpy(pordre, "mkdir ");strcat(pordre,fileName);
system(pordre);
// et on retente une ouverture
ouvre_dir = opendir(fileName);
};
// maintenant s'il y a pb, c'est vraiment un pb
if(ouvre_dir == NULL)
// le répertoire ne peut être créé, message d'erreur
{ cout << "\n erreur en creation du repertoire " << fileName << "\n"
<< " UtilLecture::CreationRepertoireResultat(.. " << endl;
Sortie(1);
}
};
// ouverture d'un fichier résultat Gmsh, comprenant un nom particulier
void UtilLecture::Ouverture_fichier_resultat_Gmsh(const string& nom)
{ // on commence par voir si le fichier existe déjà
map < string, ofstream * , std::less <string> >::iterator ili
= sort_resultat_Gmsh.find(nom);
// dans le cas où le fichier existe déjà on ne fait rien
if (ili == sort_resultat_Gmsh.end())
{// --- cas où le fichier n'existe pas
// on construit le nom de fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
strcat(fileName,"_Gmsh/"); // là il contient la racine du répertoire
strcat(fileName,ptnomCVisu); // on rajoute le début du nom du fichier
strcat(fileName,"_"); // on rajoute un séparateur
strcat(fileName,nom.c_str()); // on rajoute le nom passé en paramètre
strcat(fileName,"_Gmsh.pos"); // ajout de la fin
noms_base_fichiers_gmsh.push_back(nom);
sort_resultat_Gmsh[nom] = new ofstream(fileName);
if (ParaGlob::NiveauImpression()> 7)
cout << "\n ouverture du fichier "<< fileName << endl;
if(!(sort_resultat_Gmsh[nom]->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_resultat_Gmsh(list <string>) " << endl;
Sortie(1);
};
};
};
// ouverture d'un ensemble de fichiers: ces fichiers seront ensuite accessibles
void UtilLecture::Ouverture_fichier_resultat_Gmsh(const list <string>& t_nom)
{ // on va itérer sur les noms
list <string>::const_iterator iti,itifin=t_nom.end();
for (iti=t_nom.begin();iti != itifin; iti++)
{ const string & nom = (*iti); // pour simplifier
// on commence par voir si le fichier existe déjà
map < string, ofstream * , std::less <string> >::iterator ili
= sort_resultat_Gmsh.find(nom);
// dans le cas où le fichier existe déjà on ne fait rien
if (ili == sort_resultat_Gmsh.end())
{// --- cas où le fichier n'existe pas
// on construit le nom de fichier
char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
strcat(fileName,"_Gmsh/"); // là il contient la racine du répertoire
strcat(fileName,ptnomCVisu); // on rajoute le début du nom du fichier
strcat(fileName,"_"); // on rajoute un séparateur
strcat(fileName,nom.c_str()); // on rajoute le nom passé en paramètre
strcat(fileName,"_Gmsh.pos"); // ajout de la fin
noms_base_fichiers_gmsh.push_back(nom);
sort_resultat_Gmsh[nom] = new ofstream(fileName);
if (ParaGlob::NiveauImpression()> 7)
cout << "\n ouverture du fichier "<< fileName << endl;
if(!(sort_resultat_Gmsh[nom]->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_fichier_resultat_Gmsh(list <string>) " << endl;
Sortie(1);
};
};
};
};
// fermeture du fichier résultat Gmsh
void UtilLecture::Fermeture_fichier_resultat_Gmsh(const string& nom)
{ // on commence par voir si le fichier existe
map < string, ofstream * , std::less <string> >::iterator ili
= sort_resultat_Gmsh.find(nom);
// dans le cas où le fichier n'existe pas on ne fait rien
// mais on sort un message
if (ili == sort_resultat_Gmsh.end())
{ cout << "\n erreur en fermeture du fichier relatif au nom " << nom
<< " ce fichier n'existe pas ??? , on continue mais ...."
<< "\n UtilLecture::Fermeture_fichier_resultat_Gmsh(string nom)";
}
else// sinon fct normal
{ delete(ili->second);
sort_resultat_Gmsh.erase(ili);
// suppression du nom de la liste
noms_base_fichiers_gmsh.remove(nom);
};
};
// fermeture de tous les fichiers résultat
void UtilLecture::Fermeture_TousLesFichiersResultats_Gmsh()
{ map < string, ofstream * , std::less <string> >::iterator ili,ilifin
= sort_resultat_Gmsh.end();
for (ili=sort_resultat_Gmsh.begin();ili != ilifin;ili++)
{ delete(ili->second);
};
sort_resultat_Gmsh.erase(sort_resultat_Gmsh.begin(),sort_resultat_Gmsh.end());
noms_base_fichiers_gmsh.clear();
};
// récupération d'un fichier résultats Gmsh
ofstream & UtilLecture::Sort_resultat_Gmsh(const string& nom)
{
#ifdef MISE_AU_POINT
// on commence par voir si le fichier existe
map < string, ofstream * , std::less <string> >::iterator ili
= sort_resultat_Gmsh.find(nom);
// dans le cas où le fichier n'existe pas on sort un message
if (ili == sort_resultat_Gmsh.end())
{ cout << "\n erreur en recuperation du fichier relatif au nom " << nom
<< " ce fichier n'existe pas ??? "
<< "\n UtilLecture::Sort_resultat_Gmsh(string nom)";
Sortie(1);
return *(sort_resultat_Gmsh[nom]); // pour faire taire le compilo
}
else// sinon fct normal
#endif
{ return *(sort_resultat_Gmsh[nom]);
};
};
// ouverture du fichier CommandeVisu s'il est déjà ouvert on ne fait rien
// a priori le fichier est ouvert en lecture : lecture
// mais il peut également être en écriture : ecriture
void UtilLecture::Ouverture_CommandeVisu(string type_entree)
{ char nomm[132];
char*fileName = nomm;
strcpy(fileName, ptnomCVisu);
if (type_entree == "lecture")
// cas d'une lecture
// on regarde si on a déjà une ouverture en écriture si oui on ferme
{ if (sort_CommandeVisu != NULL)
Fermeture_CommandeVisu();
// maintenant on regarde si la lecture est déjà en cours si oui on ne fait rien
// si le flot est correcte, sinon on ouvre
if (ent_CommandeVisu == NULL)
{ ent_CommandeVisu = new fstream(strcat(fileName,".CVisu"), ios::out | ios::in);
if(!(ent_CommandeVisu->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_CommandeVisu() " << endl;
throw (ErrNouvelleDonneeCVisu(0)); // erreur en ouverture fichier pour la lecture
Sortie(1);
}
}
else if ( ent_CommandeVisu->rdstate() != 0) // pb éventuelle on redémarre le flux
{Fermeture_CommandeVisu();
ent_CommandeVisu = new fstream(strcat(fileName,".CVisu"), ios::out | ios::in);
if(!(ent_CommandeVisu->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur2 en ouverture pour la lecture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_CommandeVisu() " << endl;
throw (ErrNouvelleDonneeCVisu(0)); // erreur en ouverture fichier pour la lecture
Sortie(1);
}
}
}
else if (type_entree == "ecriture")
// cas d'une ecriture
// on regarde si on a déjà une ouverture en lecture si oui on ferme
{ if (ent_CommandeVisu != NULL)
Fermeture_CommandeVisu();
// maintenant on regarde si la lecture est déjà en cours si oui on ne fait rien
// sinon on ouvre et on se place à la fin
if (sort_CommandeVisu == NULL)
{ sort_CommandeVisu = new fstream(strcat(fileName,".CVisu"), ios::out | ios::in );
if(!(sort_CommandeVisu->is_open()))
// le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre
{ sort_CommandeVisu = new fstream(fileName, ios::out | ios::ate);
if(!(sort_CommandeVisu->is_open()))
// le fichier ne peut être ouvert, message d'erreur
{ cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileName << "\n"
<< " UtilLecture::Ouverture_CommandeVisu() " << endl;
throw (ErrNouvelleDonneeCVisu(10)); // erreur en ouverture fichier pour l'écriture
Sortie(1);
};
};
};
}; //-- fin du cas écriture
};
// fermeture du fichier CommandeVisu
void UtilLecture::Fermeture_CommandeVisu()
{ if (ent_CommandeVisu != NULL)
{// cas du fichier ouvert en lecture
delete ent_CommandeVisu;
ent_CommandeVisu = NULL;
}
if (sort_CommandeVisu != NULL)
{// cas du fichier ouvert en écriture
delete sort_CommandeVisu;
sort_CommandeVisu = NULL;
}
};
// changement du nom de fichier .CVisu
// entraîne la fermeture du fichier en cours, en lecture et en écriture
// il n'y a pas de vérification à ce niveau d'existence éventuelle
// car on ne sait pas ce que l'on veut en faire
void UtilLecture::Changement_NomCVisu(string nouveauNomCvisu)
{ // on commence par fermer le fichier en cours
Fermeture_CommandeVisu();
// maintenant on regarde si la chaine passée en paramètre est non nulle
if (nouveauNomCvisu != "")
// on définit directement le nouveau nom
{nomRacineCVisu = nouveauNomCvisu;}
else // sinon on passe en interactif
{ cout << "\n entrez le nouveau nom: ";
string nom;
nom= lect_chaine();
cout << " nom_lue: " << nom;
// dans le cas où ".CVisu" figure dans la racine, on supprime cette chaine
int posi = nomRacine.find(".CVisu");
if (posi != string::npos)
{ string nom_inter = nomRacine.substr(0,posi);
nom = nom_inter;
};
nomRacineCVisu = nom;
};
// on met à jour le pointeur
ptnomCVisu = (char*)nomRacineCVisu.c_str();
};
// lecture d'une nouvelle ligne de donnee utilisable pour l'entree de donnee
// dans le fichier de commande de visualisation (idem NouvelleDonnee mais en plus simple
// car il n'y a pas de fichier inclus)
void UtilLecture::NouvelleDonneeCVisu()
{ // on lit jusqu'à la fin de fichier(boucle infini)
int boucle=0;
try
{
Nouvel_enregCvisu (); // lecture d'un enreg ds le fichier courant
// on repositionne le flot au debut du tableau de carractere
// ouverture du flot a la longueur sans blanc
delete entCVisu;
#ifndef ENLINUX_STREAM
entCVisu = new istringstream(tablcarCVisu,strlen (tablcarCVisu)) ;
#else
entCVisu = new istrstream(tablcarCVisu,(long)strlen (tablcarCVisu)) ;
#endif
}
// sortie anormale du programme
catch (ErrNouvelEnregCVisu erreur)
{ if ( erreur.lecture == 1) // on a atteind une fin de fichier
throw (ErrNouvelleDonneeCVisu(1));
else
throw (ErrNouvelleDonneeCVisu(-1)); // erreur inconnue
}
};
// recherche dans le fichier de commande la chaine de caractère passée en paramètre
// retour false: si on ne trouve pas la chaine
// retour true: si on la trouve, et dans ce cas le pointeur courant du fichier est
// positionné sur la ligne de la chaine
bool UtilLecture::PositionEtExisteCVisu(const string chaine)
{ // on ouvre le fichier en lecture si ce n'est pas fait
try{
Ouverture_CommandeVisu("lecture");
// on commence par se positionner en début du fichier
ent_CommandeVisu->seekg(ios::beg);
// on effectue la lecture jusqu'à trouver la chaine
while (strstr(tablcarCVisu,chaine.c_str())==NULL)
NouvelleDonneeCVisu();
// arrêt, on a trouvé la chaine et on est bien positionné
return true;
}
// sortie de la lecture hors du while
catch (UtilLecture::ErrNouvelleDonneeCVisu erreur)
{ if ( erreur.lecture != 1)
{ // erreur en lecture
cout << "\n **** ERREUR en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n UtilLecture::PositionEtExisteCVisu(..";
}
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)// erreur inconnue
{ cout << "\n **** ERREUR inconnuee en lecture du fichier de commande de visualisation "
<< "\n on continue quand meme, mais il y aura peut-etre un probleme de coherence pour la suite";
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n 2 UtilLecture::PositionEtExisteCVisu(..";
}
// quelque soit la cause, on n'a pas trouvé la chaine
return false;
};
//fichier CommandeVisu dans lequel sont lus les enregistrements
// en lecture directe
ifstream * UtilLecture::Ent_CommandeVisu()
{ if (ent_CommandeVisu == NULL)
{ // cas ou le fichier n'est pas ouvert on l'ouvre
Ouverture_CommandeVisu("lecture");
}
return (ifstream*) ent_CommandeVisu;
};
//------------ utilitaire de lecture d'un parametre précédé d'un mot clé, avec une restriction
// sur les valeurs
// lecture_effective: indique si oui ou non il y a eu lecture
// val_defaut: si la grandeur n'est pas lue, elle est mise par défaut = val_defaut
// nom_class_methode: le nom de la methode qui appel l'utilitaire -> sortie dans le message si pb
// min max : les bornes entre lesquelles doit se trouver le parametre lue sinon -> génération d'une erreur et arrêt
// si max < min alors la condition n'est pas prise en compte
// mot_cle : mot_cle devant précéder le parametre
// parametre: le parametre à lire
// retourne le parametre lue ou la valeur par défaut
bool UtilLecture::Lecture_un_parametre_int(int val_defaut,const string& nom_class_methode
,int min, int max, string& mot_cle, int& parametre ) const
{ string nom; bool lecture_effective=false;
if (strstr(tablcar,mot_cle.c_str())!=NULL)
{ *(entree) >> nom;
if (nom != mot_cle)
{ cout << "\n erreur en lecture du parametre "<< mot_cle
<< "\n on attendait la chaine " << mot_cle << " au lieu de: " << nom
<< "\n " << nom_class_methode << "( ... " << endl ;
Sortie(1);
};
//sinon c'est ok
*(entree) >> parametre;
if (max > min)
{if ((parametre < min ) || (parametre > max ))
{ cout << "\n erreur en lecture du parametre " << mot_cle
<< "\n pour l'instant seuls les types " << min << " a " << max << " sont implantes, valeur lue: " << parametre
<< "\n " << nom_class_methode << "( ... " << endl ;
Sortie(1);
};
};
lecture_effective = true;
}
else // sinon on met la valeur par défaut
{ parametre = val_defaut;};
// retour
return lecture_effective;
};
// idem pour un double
bool UtilLecture::Lecture_un_parametre_double(double val_defaut,const string& nom_class_methode
,double min, double max,const string& mot_cle, double& parametre ) const
{ string nom; bool lecture_effective=false;
if (strstr(tablcar,mot_cle.c_str())!=NULL)
{ *(entree) >> nom;
if (nom != mot_cle)
{ cout << "\n erreur en lecture du parametre "<< mot_cle
<< "\n on attendait la chaine " << mot_cle << " au lieu de: " << nom
<< "\n " << nom_class_methode << "( ... " << endl ;
Sortie(1);
};
//sinon c'est ok
*(entree) >> parametre;
if (max > min)
{if ((parametre < min ) || (parametre > max ))
{ cout << "\n erreur en lecture du parametre " << mot_cle
<< "\n pour l'instant seuls les types " << min << " a " << max << " sont implantes, valeur lue: " << parametre
<< "\n " << nom_class_methode << "( ... " << endl ;
Sortie(1);
};
};
lecture_effective = true;
}
else // sinon on met la valeur par défaut
{ parametre = val_defaut;};
// retour
return lecture_effective;
};
// lecture et passage d'un mot clé: il y a simplement vérification que c'est le bon mot clé qui est lue
// ramène si oui ou non le mot clé à été lue
bool UtilLecture::Lecture_et_verif_mot_cle(const string& nom_class_methode,const string& mot_cle) const
{ string nom; bool lecture_effective=false;
if (strstr(tablcar,mot_cle.c_str())!=NULL)
{ *(entree) >> nom;
if (nom != mot_cle)
{ cout << "\n erreur en lecture du mot cle "<< mot_cle
<< "\n on a lue " << nom
<< nom_class_methode << "( ... ";
Sortie(1);
};
//sinon c'est ok
lecture_effective = true;
}
else // sinon problème
{ cout << "\n erreur en lecture du mot cle "<< mot_cle
<< "\n il n'existe pas sur la ligne " << tablcar
<< nom_class_methode << "( ... ";
Sortie(1);
};
// retour
return lecture_effective;
};
// idem pour un mot clé et un string: nom
bool UtilLecture::Lecture_mot_cle_et_string(const string& nom_class_methode,const string& mot_cle,string& nom_ret) const
{ string nom; bool lecture_effective=false;
if (strstr(tablcar,mot_cle.c_str())!=NULL)
{ *(entree) >> nom;
if (nom != mot_cle)
{ cout << "\n erreur en lecture du mot cle "<< mot_cle
<< "\n on a lue " << nom
<< nom_class_methode << "( ... ";
Sortie(1);
};
//sinon c'est ok
lecture_effective = true;
}
else // sinon problème
{ cout << "\n erreur en lecture du mot cle "<< mot_cle
<< "\n il n'existe pas sur la ligne " << tablcar
<< nom_class_methode << "( ... ";
Sortie(1);
};
// puis lecture du string
*(entree) >> nom_ret;
// retour
return lecture_effective;
};
// ------------------------------- méthodes protégées ---------------------------------
//fichier CommandeVisu dans lequel sont lus les enregistrements
// en écriture
ofstream * UtilLecture::Sort_CommandeVisu()
{ if (sort_CommandeVisu == NULL)
{ // cas ou le fichier n'est pas ouvert on l'ouvre
Ouverture_CommandeVisu("ecriture");
}
return (ofstream*) sort_CommandeVisu;
} ;
Reference in a new issue Copy permalink