diff --git a/References/Lect_reference.cc b/References/Lect_reference.cc new file mode 100644 index 0000000..67fb294 --- /dev/null +++ b/References/Lect_reference.cc @@ -0,0 +1 @@ +// FICHIER : Lecture_reference.cp #include #include #include #include #include #include "Lect_reference.h" Tableau Lect_reference (char* nom_fichier) // LECTURE DES REFERENCES DU MAILLAGE ET STOCKAGE DE TOUTES LES // REFERENCES DANS UN TABLEAU { FILE* fichier; char ligne[80]; // *** Ouverture du fichier de donnees *** if ( (fichier=fopen(nom_fichier,"r"))==NULL ) { cout << "ERREUR D'OUVERTURE DU FICHIER :"; cout << nom_fichier << "\n"; exit(1); }; // *** Calcul du nombre de reference *** // ( et sauvegarde de l'indicateur de position des lignes // du fichier ou sont definies des references ) unsigned long int position=0; //indicateur de position dans le fichier lu Liste liste_posit; // liste contenant des positions correspondant // a la definition d'une reference // num_ligne est le numero de la derniere ligne lue (utile pour // les messages d'erreur) int num_ligne=0; // Parcours de l'ensemble du fichier et stockage dans liste_posit_ref // des indicateurs de position while ( feof(fichier)==0 ) { position=ftell(fichier);// sauvegarde dans position de la position // courante dans le fichier num_ligne=num_ligne+1; if ( (fgets(ligne,80,fichier)==NULL) && (feof(fichier)==0) ) { cout << "ERREUR DE LECTURE DU FICHIER :"; cout << nom_fichier << "\n"; cout << "Numero de la derniere ligne lue correctement :"; cout << (num_ligne-1) << "\n"; exit(1); }; if ( (strstr(ligne,"N_R")!=NULL) || (strstr(ligne,"E_R")!=NULL) || (strstr(ligne,"F_R")!=NULL) || (strstr(ligne,"A_R")!=NULL) ) // presence d'un nom de reference liste_posit.Ajout(position); ligne[0]='\0'; }; if ( liste_posit.Nombre()==0 ) { cout << "ERREUR DE LECTURE DU FICHIER : "; cout << nom_fichier << "\n"; cout << "Aucune reference n'a ete trouve !\n"; }; // *** Lecture des noms et des numeros des references *** // *** Stockage des informations dans tab_ref *** rewind(fichier); Tableau tab_ref(liste_posit.Nombre()); // Positionnement sur le premier element de liste_posit liste_posit.Debut(); // Placement de l'indicateur de position sur une ligne // definissant une reference et lecture des donnees de la // reference errno=0; for (int i=1;i<=liste_posit.Nombre();i++) { char nom_ref[10]; int numero=0; Liste liste_num; // liste des numeros d'une reference fseek(fichier,liste_posit.Element(),SEEK_SET); fscanf(fichier,"%10s",nom_ref); // lecture du nom de la reference if ( feof(fichier)!=0 ) { cout << "ERREUR DE LECTURE DU FICHIER :"; cout << nom_fichier << "\n"; cout << "Fin du fichier atteinte avant la lecture"; cout << " totale des donnees !\n"; exit(1); }; if ( errno!=0 ) { cout << "ERREUR DE LECTURE DU FICHIER : "; cout << nom_fichier << "\n"; if ( i>1 ) { cout << "Nom de la derniere reference lue correctement : "; cout << tab_ref(i-1).Nom() << "\n"; exit(1); } else { cout << "Probleme de lecture de la premiere reference\n"; exit(1); }; }; while ( fscanf(fichier,"%d", &numero)==1 ) // lecture des numeros d'une reference et stockage dans liste_num liste_num.Ajout(numero); if ( liste_num.Nombre()==0 ) { cout << "ERREUR DE LECTURE DU FICHIER : "; cout << nom_fichier << "\n"; cout << "La reference de nom " << nom_ref << " est vide \n"; }; Tableau tab_num(liste_num.Nombre()); liste_num.Debut(); for (int j=1;j<=liste_num.Nombre();j++) // stockage a partir de la liste des numeros liste_num de l'ensemble // des numeros d'une reference dans le tableau tab_num { tab_num(j)=liste_num.Element(); liste_num.Suivant(); }; Reference ref(tab_num,nom_ref); tab_ref(i)=ref; // sauvegarde de l'ensemble des donnees d'une reference dans tab_ref liste_posit.Suivant(); }; // *** Fermeture du fichier de donnees *** if ( fclose(fichier)==-1 ) { cout << " ERREUR DE FERMETURE DU FICHIER "; cout << nom_fichier << "\n"; exit(1); }; // *** Renvoie du tableau de reference *** return tab_ref; }; \ No newline at end of file diff --git a/References/Lect_reference.h b/References/Lect_reference.h new file mode 100644 index 0000000..9adf0d3 --- /dev/null +++ b/References/Lect_reference.h @@ -0,0 +1,17 @@ +// FICHIER : Lect_reference.h + + +#ifndef LECT_REFERENCE_H +#define LECT_REFERENCE_H + + +#include "Liste_T.cc +#include "Reference.h" +#include "Tableau_T.h" + + +// Lecture des references definies dans le fichier au format ".lis" de nom : nom_fichier +Tableau Lect_reference (char* nom_fichier); + + +#endif \ No newline at end of file diff --git a/References/LesReferences.cc b/References/LesReferences.cc new file mode 100644 index 0000000..86a7892 --- /dev/null +++ b/References/LesReferences.cc @@ -0,0 +1,1172 @@ + +#include "LesReferences.h" +#include "PtTabRel.h" +#include "ReferenceAF.h" +#include "ReferenceNE.h" +#include "ReferencePtiAF.h" + +//-------- une méthode permettant d'utiliser des tableaux de map de références ----- + // surcharge de l'operator d'ecriture + ostream & operator << (ostream & sort, const map < string, Reference*, std::less > & ) + { // tout d'abord un indicateur donnant le type + if (ParaGlob::Francais()) {sort << " \n erreur (de developpement) a une fonction d'ecriture << d'une map de reference " + << " voir LesReference.h "; } + else {sort << " \n error (for developper) for the writing method << concerning a map of references " + << " see LesReference.h "; } + Sortie(1); return sort; + }; +//----------- fin de la méthode permettant d'utiliser des tableaux de map de références ----- + +// --------------- variables statiques --------- + MotCle LesReferences::motCle; // liste des mots clés + +LesReferences::LesReferences () : // par defaut + t_mapDeRef(),ref(NULL),num_mail_presuivant(0),listeNomMail(NULL) + { nbMaille =1; + indic = 0; + }; +// DESTRUCTEUR : +LesReferences::~LesReferences () + { // effacement des grandeurs pointées par la liste de référence + int taille = t_mapDeRef.Taille(); + for (int i=1;i<=taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + map < string, Reference*, std::less >::iterator il,ilfin = mapDeRef.end(); + for (il=mapDeRef.begin() ; il != ilfin; il++) + if ((*il).second != NULL) {delete (*il).second;(*il).second=NULL;}; + mapDeRef.erase(mapDeRef.begin(),mapDeRef.end()); + }; + }; + +// def du numero de maillage courant, utilise avant la lecture +void LesReferences::NbMaille(int nb) { nbMaille = nb; }; +// def du type de reference a lire, utilise avant la lecture +void LesReferences::Indic(string type) + { if (type == "noeud") indic = 1; + else if (type == "element") indic =2; + else if(type == "surface") indic = 3; + else if(type == "arete")indic = 4; + else if(type == "noeud_element")indic = 5; + else if(type == "pt_integ_element")indic = 6; + else if(type == "pt_integ_face_element")indic = 7; + else if(type == "pt_integ_arete_element")indic = 8; + else if(type == "rien_actuellement") indic = 0; + else + { if (ParaGlob::Francais()) {cout << " \n **** erreur de type de reference, type donne = " << type;} + else {cout << " \n **** error of type of reference, type = " << type;} + cout << "LesReferences::Indic(string type)" << endl; + Affiche(); + Sortie(1); + }; + }; + +// lecture des references + void LesReferences::Lecture(UtilLecture & entreePrinc) + { // on lit des references temps qu'il n'y a pas de pb + if (indic < 0) + { if (ParaGlob::Francais()) + {cout << " \n erreur en lecture de reference, le type de reference n\'st pas defini " ;} + else {cout << " \n error in reading a reference, the reference type is not defined " ;}; + cout << "\n LesReferences::LectureLesReferences(etc ... " << endl; + Affiche(); + Sortie(1); + } + while ( LectureReference(entreePrinc)) + // la methode LectureReference cree une référence pointée par ref + { // verification que l'on n'a pas deux references identiques + if (Existe(ref->Nom(),ref->Nbmaille())) + { if (ParaGlob::Francais()) + { cout <<" \n Erreur de lecture de reference, deux refs ont le meme nom \n"; + cout <<" nom = " << ref->Nom() << " pour le meme maillage nb: " + << ref->Nbmaille() << '\n';} + else { cout <<" \n Error in reading a reference, two refs have the same name \n"; + cout <<" name = " << ref->Nom() << " for the same mesh nb: " + << ref->Nbmaille() << '\n';} + cout <<"LesReferences::LectureLesReferences(UtilLecture & entreePrinc)" + << endl; + entreePrinc.MessageBuffer("lecture des references"); + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie (1); + } + else + {int num_mail = ref->Nbmaille(); + if (num_mail < 1 ) + // on vérifie que le numéro de maillage est licite + { if (ParaGlob::Francais()) + { cout << "\n erreur, on veut ajouter une reference sur le maillage numero nul ou negatif : " << num_mail << " ";} + else { cout << "\n error, we cannot add a reference on the mesh, number : " << num_mail << " ";} + ref->Affiche(); + cout << "\n LesReferences::LectureLesReferences(... "; + Sortie(1); + } + else if (num_mail > t_mapDeRef.Taille()) + // maintenant on regarde si l'on a déjà enregistré dans ce maillage + { t_mapDeRef.Change_taille(num_mail); + }; + // puis on enregistre + t_mapDeRef(num_mail)[ref->Nom()]=ref; + // t_mapDeRef(nbMaille)[ref->Nom()]= ref; + }; + } + }; + +// ajout d'une référence déjà construite par ailleurs +void LesReferences::Ajout_reference(Reference * refi) + { int num_mail = refi->Nbmaille(); + if (num_mail < 1 ) + // on vérifie que le numéro de maillage est licite + { if (ParaGlob::Francais()) + { cout << "\n erreur, on veut ajouter une reference sur le maillage numero nul ou negatif : " + << num_mail << " "; + } + else + { cout << "\n error, we cannot add a reference on the mesh, number : " << num_mail << " ";} + refi->Affiche(); + cout << "\n LesReferences::Ajout_reference(Reference * refi) "; + Sortie(1); + } + else if (num_mail > t_mapDeRef.Taille()) + // maintenant on regarde si l'on a déjà enregistré dans ce maillage + { t_mapDeRef.Change_taille(num_mail); + }; + // supprime les doublons internes éventuels dans la référence + refi->Supprime_doublons_internes(); + // puis on enregistre + t_mapDeRef(num_mail)[refi->Nom()]=refi; + return; + }; + +// affichage et definition interactive des commandes +// nbMaxiNoeud: nombre maxi de noeud pour les exemples +void LesReferences::Info_commande_lesRef(int nbMaxiNoeud,int nbMaxiElem,UtilLecture * entreePrinc,int cas) + { + // on dimensionne la taille de t_mapDeRef + if ( nbMaille > t_mapDeRef.Taille()) + // maintenant on regarde si l'on a déjà enregistré dans ce maillage + { t_mapDeRef.Change_taille(nbMaille); + }; + + + switch (cas) + { case 1: + {// en fait on s'occupe ici uniquement des références de noeuds + ref = new ReferenceNE("N_exemple_ref_NE", nbMaille,1); + ref-> Info_commande_Ref(nbMaxiNoeud,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + break; + } + case 2: + {// cas de toutes les références + ref = new ReferenceNE(nbMaille,1); // cas d'une ref de noeuds + ref-> Info_commande_Ref(nbMaxiNoeud,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferenceNE(nbMaille,2); // cas d'une ref d'elements + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferenceAF(nbMaille,3); // cas d'une ref de surfaces + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferenceAF(nbMaille,4); // cas d'une ref d'arrete + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferenceAF(nbMaille,5); // cas d'une ref de noeud associé à un élément + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferenceAF(nbMaille,6); // cas d'une ref de point d'intégration associé à un élément + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferencePtiAF(nbMaille,7); // cas d'une ref de point d'intégration associé à une face d'élément + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + ref = new ReferencePtiAF(nbMaille,8); // cas d'une ref de point d'intégration associé à une arete d'élément + ref-> Info_commande_Ref(nbMaxiElem,entreePrinc,cas); + t_mapDeRef(nbMaille)[ref->Nom()]= ref; + + break; + } + default : + { if (ParaGlob::Francais()) {cout << "\nErreur : valeur incorrecte du cas = " << cas << "\n";} + else {cout << "\nError : incorrect value for the case = " << cas << "\n";} + cout << "LesReferences::Info_commande_lesRef..." ; + Sortie(1); + }; + } + }; + +// affichage des informations contenu dans les references +// par défaut affiche toutes les infos +// si niveau = 1 : affiche que les noms des ref +void LesReferences::Affiche(int niveau) const + { int taille = t_mapDeRef.Taille(); + for (int i=1;i<=taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + map < string, Reference*, std::less >::const_iterator i_map; + if (ParaGlob::Francais()) {cout << " \n ------- affichage des listes de references ------- \n ";} + else {cout << " \n ------- display of the lists of references ------- \n ";}; + for (i_map=mapDeRef.begin() ; i_map != mapDeRef.end(); i_map++) + if (!niveau) + (*i_map).second->Affiche(); + else cout << " " << (*i_map).first ; + cout << endl; + }; + }; + +// affichage des informations contenu dans les references d'un certain type +// défini par indic : +// indic = 1 -> noeud, =2 -> element +// =3 -> surface associée à un élément , =4 -> arete associée à un élément +// =5 -> noeud associée à un élément +// =6 -> point d'intégration associée à un élément +// =7 -> de points d'intégrations relatifs à des surfaces d'éléments +// =8 -> de points d'intégrations relatifs à des arrete d'éléments +// =0 -> rien_actuellement +// par défaut affiche toutes les infos +// si niveau = 1 : affiche que les noms des ref +void LesReferences::Affiche(int indic, int niveau) const + { int taille = t_mapDeRef.Taille(); + for (int i=1;i<=taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + map < string, Reference*, std::less >::const_iterator i_map; + if (ParaGlob::Francais()) {cout << " \n ------- affichage references ------- \n ";} + else {cout << " \n ------- display references ------- \n ";}; + for (i_map=mapDeRef.begin() ; i_map != mapDeRef.end(); i_map++) + if ((*i_map).second->Indic() == indic) + {if (niveau==1) + cout << " " << (*i_map).first ; + else (*i_map).second->Affiche(); + }; + cout << endl; + }; + }; + + +// Affiche les donnees des références pour le maillage imail dans un fichier +// dont le nom est construit à partir du nom du maillage au format ".lis" +void LesReferences::Affiche_dans_lis(const string& nom_maillage,int imail) + { // tout d'abord on vérifie qu'il existe des références pour ce maillage + // ce qui peut-être fait de manière très simple en testant t_mapDeRef.Taille() + // si l'élément de tableau n'existe pas, ce n'est pas la peine de continuer, il n'y a pas de ref + // s'il existe, il y a peut-être des ref ... donc on continue + if (imail > t_mapDeRef.Taille()) + return; + // ouverture du fichier pour les noeuds + char namm[132]; + char*fileNoome = namm; + strcpy(fileNoome, nom_maillage.c_str()); + ofstream * sur_sort = new ofstream (strcat(fileNoome,".lis")); + ofstream & sort = * sur_sort; + if(!(sort.is_open())) + // le fichier ne peut être ouvert, message d'erreur + { if (ParaGlob::Francais()) + {cout << "\n erreur en ouverture pour l'ecriture du fichier " << fileNoome << "\n";} + else {cout << "\n error, when trying to open for writing, the file " << fileNoome << "\n";}; + cout << " Maillage::Affiche_dans_her_lis(.... " << endl; + Sortie(1); + }; + // écriture de l'entete + if (ParaGlob::Francais()) + {sort << "\n ###########################################################################" + << "\n # ecriture automatique d'un maillage au format .lis, par Herezh++ #" + << "\n ###########################################################################";} + else {sort << "\n ###########################################################################" + << "\n # automatic writing by Herezh++, of a mesh with format .lis #" + << "\n ###########################################################################";}; + sort << "\n # version: " << ParaGlob::NbVersion() << "\n \n \n "; + // --- écriture des références de noeuds + if (ParaGlob::Francais()) {sort << "\n # -- reference de noeud ";} + else {sort << "\n # -- reference of nodes ";}; + // on passe en revue les différentes références pour trouver la bonne + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(imail); + map < string, Reference*, std::less >::const_iterator il,ilfin=mapDeRef.end(); + for (il=mapDeRef.begin();il!=ilfin;il++) + if ((*il).second->Indic()==1) + {// on a trouvé une référence de noeud pour le maillage considéré + (*il).second->Affiche_dans_lis(sort); // affichage + }; + // --- écriture des références des éléments + if (ParaGlob::Francais()) {sort << "\n # -- reference des elements ";} + else {sort << "\n # -- reference of elements ";}; + // on passe en revue les différentes références pour trouver la bonne + for (il=mapDeRef.begin();il!=ilfin;il++) + if ((*il).second->Indic()==2) + {// on a trouvé une référence d'element pour le maillage considéré + (*il).second->Affiche_dans_lis(sort); // affichage + } + // --- écriture des références de pt d'integ, noeuds, faces et arretes + if (ParaGlob::Francais()) + {sort << "\n # -- references de pt d'integ, noeuds, faces et arretes associes a des elements ";} + else {sort << "\n # -- references of Gauss points, nodes, facets, segments, associated with elements ";}; + // on passe en revue les différentes références pour trouver la bonne + for (il=mapDeRef.begin();il!=ilfin;il++) + if (((*il).second->Indic()==3)||((*il).second->Indic()==4) + ||((*il).second->Indic()==5)||((*il).second->Indic()==6) + ||((*il).second->Indic()==7)||((*il).second->Indic()==8)) + {// on a trouvé une référence de pt d'integ, noeuds, faces et arretes pour le maillage considéré + (*il).second->Affiche_dans_lis(sort); // affichage + }; + // quelques lignes blanches à la fin du fichier + sort << "\n \n \n"; + // fermeture du fichier + delete sur_sort; + }; + + + // initialise le questionnement de la récupération de référence et + // retourne la première référence si elle existe sinon un pointeur nul +const Reference* LesReferences::Init_et_Premiere() + { num_mail_presuivant=0; + Reference * refret = NULL; + int t_taille = t_mapDeRef.Taille(); + if ( t_taille == 0) + return NULL; + // sinon on boucle sur les éléments du tableaux + // et on cherche la première ref valide qui existe + for (int i=1;i<=t_taille;i++) + { iref = t_mapDeRef(i).begin(); + if (iref != t_mapDeRef(i).end()) + { num_mail_presuivant=i; + refret = (*iref).second; + break; + }; + }; + // retour + return refret; + }; + + // retourne la référence suivante ou, s'il n'y en n'a plus, retourne + // un pointeur nul +const Reference* LesReferences::Reference_suivante() + { Reference * refret = NULL; + if (num_mail_presuivant != 0) + {iref++; + if (iref != t_mapDeRef(num_mail_presuivant).end()) + { return (*iref).second; + } + // donc arrivé ici cela veut dire qu'on est sur une fin + else + { // sinon on boucle sur les éléments du tableaux qui restent + // et on cherche la première ref valide qui existe + int t_taille = t_mapDeRef.Taille(); + for (int i=num_mail_presuivant+1;i<=t_taille;i++) + { iref = t_mapDeRef(i).begin(); + if (iref != t_mapDeRef(i).end()) + { num_mail_presuivant=i; + refret = (*iref).second; + break; + }; + }; + }; + }; + // retour + return refret; + }; + +// test si la reference existe reellement +// retourne false si n'existe pas , true sinon +bool LesReferences::Existe(const string & st1,int num_mail) const + { // tout d'abord on regarde si le tableau de map n'est pas vide + if (t_mapDeRef.Taille() == 0) + return false; + // sinon on peut continuer + bool existe=true; + if (num_mail > t_mapDeRef.Taille()) + { existe = false; + } + else if (t_mapDeRef(num_mail).find(st1) == t_mapDeRef(num_mail).end()) + { existe = false; + }; + // sinon c'est ok + return existe; + }; + +// idem mais avec un nom de maillage +bool LesReferences::Existe(const string & st1,const string* nom_mail) const +{ // tout d'abord on regarde si le tableau de map n'est pas vide + if (t_mapDeRef.Taille() == 0) + return false; + // sinon on peut continuer + // on regarde si le nom de maillage est licite + if (nom_mail == NULL) + { // acceptable que si l'on a un seul maillage + #ifdef MISE_AU_POINT + if (listeNomMail != NULL) + if (listeNomMail->size() != 1) + if (ParaGlob::NiveauImpression() >2) + { if (ParaGlob::Francais()) + {cout << "\n warning: la reference demandee= " << st1 << " , n'a pas de nom de maillage associe" + << " alors qu'il y a plusieurs maillage defini !! : on considere que c'est une ref du premier maillage";} + else {cout << "\n warning: the wanted reference " << st1 << " , has no associated mesh " + << " but several meshes exist !! : we consider that it is a ref for the first mesh ";} + if (ParaGlob::NiveauImpression() >5) + { if (ParaGlob::Francais()) {cout << "\n nom_de_maillages= ";} + else {cout << "\n names of the meshes = ";} + map < string, int , std::less >::const_iterator ili,ilifin=listeNomMail->end(); + for (ili = listeNomMail->begin();ili != ilifin; ili++) + cout << (*ili).first << ", " ; + cout << "\n LesReferences::Existe(const string & st1,const string* nom_mail) "; + }; + } +// Sortie(1); + #endif + // on ramène le cas du premier maillage qui doit exister + return Existe(st1,1); + } + else + { + #ifdef MISE_AU_POINT + // on regarde si le nom de maillage existe dans la liste + if (listeNomMail->find(*nom_mail) == listeNomMail->end()) + { if (ParaGlob::Francais()) {cout << "\nErreur : le nom de maillage : " << *nom_mail << " n'existe pas \n";} + else {cout << "\nError : the name of the mesh : " << *nom_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + cout << "LesReferences::Existe(const string & st1,const string& nom_mail) \n"; + Sortie(1); + } + #endif + return Existe(st1,(*(listeNomMail->find(*nom_mail))).second); + }; +}; + +// retourne la reference correspondant a une cle +const Reference& LesReferences::Trouve(const string & st1,int num_mail) const +{ if (num_mail > t_mapDeRef.Taille()) + { if (ParaGlob::Francais()) + {cout << " \n pb la reference de nom " << st1 << " pour le maillage nb= "<< num_mail << " n'existe pas \n";} + else {cout << "\nError : the reference with the name " << st1 << " for the mesh nb= " << num_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + { cout << " \n LesReferences::Trouve(const string & st1,int num_mail) " << endl;}; + Sortie (1); + } + else if (t_mapDeRef(num_mail).find(st1) == t_mapDeRef(num_mail).end()) + { if (ParaGlob::Francais()) + {cout << " \n pb la reference de nom " << st1 << " pour le maillage nb= "<< num_mail << " n'existe pas \n";} + else {cout << "\nError : the reference with the name " << st1 << " for the mesh nb= " << num_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + { cout << " \n LesReferences::Trouve(const string & st1,int num_mail) " << endl;}; + Sortie (1); + }; + // sinon c'est ok + return *(t_mapDeRef(num_mail)[st1]); +}; + +// idem mais avec un nom de maillage +const Reference& LesReferences::Trouve(const string & st1,const string* nom_mail) const + { // on regarde si le nom de maillage est licite + if (nom_mail == NULL) + { // acceptable que si l'on a un seul maillage + #ifdef MISE_AU_POINT + if (listeNomMail->size() != 1) + if (ParaGlob::NiveauImpression() >2) + { if (ParaGlob::Francais()) + {cout << "\n warning: la reference demandee= " << st1 << " , n'a pas de nom de maillage associe" + << " alors qu'il y a plusieurs maillage defini !! : on considere que c'est une ref du premier maillage";} + else {cout << "\n warning: the wanted reference " << st1 << " , has no associated mesh " + << " but several meshes exist !! : we consider that it is a ref for the first mesh ";} + if (ParaGlob::NiveauImpression() >5) + { if (ParaGlob::Francais()) {cout << "\n nom_de_maillages= ";} + else {cout << "\n names of the meshes = ";} + map < string, int , std::less >::const_iterator ili,ilifin=listeNomMail->end(); + for (ili = listeNomMail->begin();ili != ilifin; ili++) + cout << (*ili).first << ", " ; + cout << "\n LesReferences::Trouve(const string & st1,const string& nom_mail) "; + }; +// Sortie(1); + }; + #endif + // on ramène le cas du premier maillage qui doit exister + return Trouve(st1,1); + } + else + { + #ifdef MISE_AU_POINT + // on regarde si le nom de maillage existe dans la liste + if (listeNomMail->find(*nom_mail) == listeNomMail->end()) + { if (ParaGlob::Francais()) {cout << "\nErreur : le nom de maillage : " << *nom_mail << " n'existe pas \n";} + else {cout << "\nError : the name of the mesh : " << *nom_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + cout << "LesReferences::Trouve(const string & st1,const string& nom_mail) \n"; + Sortie(1); + }; + #endif + return Trouve(st1,(*(listeNomMail->find(*nom_mail))).second); + }; + }; + +// mise à jour des références de noeud, dans le cas où les numéros de noeuds ont changés +//1) cas où l'on supprime éventuellement des noeuds de la référence, qui ne sont plus référencé +// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" +// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de ce noeud +// = false indique qu'il continue d'être actif +void LesReferences::Mise_a_jour_ref_noeud(Tableau & nv_tab,int num_mail,Tableau & non_referencer) +{ bool fr = ParaGlob::Francais(); // pour simplifier + // on vérifie le numéro de maillage + if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille())) + { if (fr) {cout << "\n **** bizarre on demande de changer la numerotation de noeuds de reference pour le" + << " maillage numero: " << num_mail << " qui soit n'existe pas ou soit n'a pas de reference !! ";} + else {cout << "\n **** strange, we try to change the numerotation of nodes belonging to a reference of a " + << " mesh number : " << num_mail << " which does not exist or does not contain any reference !! ";}; + }; + // on balaie la map + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(num_mail); + map < string, Reference*, std::less >::iterator il,ilfin = mapDeRef.end(); +// list ::const_iterator il,ilfin=listeDeRef.end(); + int nb_noeud = nv_tab.Taille(); + for (il=mapDeRef.begin() ; il != ilfin; il++) + { if ((*il).second->Indic() == 1) + { // cas où il s'agit d'une référence de noeud + ReferenceNE* refe = ((ReferenceNE*) (*il).second); // on récupère la référence + int nb_el = refe->Taille(); + // premier passage on change les numéros + int nb_noeud_supprime = 0; // nombre de noeuds supprimés + for (int i=1; i<= nb_el; i++) + { int num_ancien = refe->Numero(i); + // on vérifie que le noeud continue d'être valide + if (non_referencer(num_ancien)) + { if (ParaGlob::NiveauImpression() > 3) + {if (fr) {cout << "\n suppression du noeud " << num_ancien << " dans la reference " + << refe->Nom() << " maillage:" << num_mail ;} + else {cout << "\n erasure of the node " << num_ancien << " in the reference " + << refe->Nom() << " mesh :" << num_mail ;}; + }; + // on commence par mettre -100 dans le tableau de num et ensuite on retassera le tableau à la fin + refe->Change_num_dans_ref(i,-100); + nb_noeud_supprime++; + } + else // sinon il faut le garder + { // on vérifie que le numéro de la référence est licite (normalement il doit l'être) + if ((num_ancien > 0) && (num_ancien <= nb_noeud)) + {refe->Change_num_dans_ref(i,nv_tab(num_ancien));} + else + {if (fr) {cout << "\n erreur dans la mise a jour d'une reference , le numero " + << num_ancien << " de la liste " + << " n'appartient pas a l'intervalle des noeuds disponibles [1," << nb_noeud << "] ";} + else {cout << "\n error during the update of a reference, the number " + << num_ancien << " in the list " + << " does not belong to the range of existing nodes [1," << nb_noeud << "] ";}; +// debug cout << " \n non_referencer(num_ancien) " << non_referencer(num_ancien) << endl; + refe->Affiche(); + Sortie(1); + }; + }; + }; + // second passage dans le cas où l'on a supprimé des noeuds + if (nb_noeud_supprime) + {// a) on fait un décalage dans le tableau initial + int indice_new = 1; + for (int i=1; i<= nb_el; i++) + { if (refe->Numero(i) != -100) + {refe->Change_num_dans_ref(indice_new,refe->Numero(i)); + indice_new++; + } + }; + // b) on retasse le tableau + Tableau tab_inter = refe->Tab_num(); + tab_inter.Change_taille(nb_el-nb_noeud_supprime); + refe->Change_tab_num(tab_inter); + }; + // on supprime les doublons éventuels + refe->Supprime_doublons_internes(); + }; + }; +}; + +// mise à jour des références de noeud, dans le cas où les numéros de noeuds ont changés +//2) cas où on considère tous les noeuds +// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" +void LesReferences::Mise_a_jour_ref_noeud(Tableau & nv_tab,int num_mail) +{ bool fr = ParaGlob::Francais(); // pour simplifier + // on vérifie le numéro de maillage + if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille())) + { if (fr) {cout << "\n **** bizarre on demande de changer la numerotation de noeuds de reference pour le" + << " maillage numero: " << num_mail << " qui soit n'existe pas ou soit n'a pas de reference !! ";} + else {cout << "\n **** strange, we try to change the numerotation of nodes belonging to a reference of a " + << " mesh number : " << num_mail << " which does not exist or does not contain any reference !! ";}; + }; + // on balaie la map + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(num_mail); + map < string, Reference*, std::less >::iterator il,ilfin = mapDeRef.end(); +// list ::const_iterator il,ilfin=listeDeRef.end(); + int nb_noeud = nv_tab.Taille(); + for (il=mapDeRef.begin() ; il != ilfin; il++) + { if ((*il).second->Indic() == 1) + { // cas où il s'agit d'une référence de noeud + ReferenceNE* refe = ((ReferenceNE*) (*il).second); // on récupère la référence + int nb_el = refe->Taille(); + for (int i=1; i<= nb_el; i++) + { int num_ancien = refe->Numero(i); + // on vérifie que le numéro de la référence est licite (normalement il doit l'être) + if ((num_ancien > 0) && (num_ancien <= nb_noeud)) + {refe->Change_num_dans_ref(i,nv_tab(num_ancien));} + else + {if (fr) {cout << "\n erreur dans la mise a jour d'une reference , le numero " + << num_ancien << " de la liste " + << " n'appartient pas a l'intervalle des noeuds disponibles [1," << nb_noeud << "] ";} + else {cout << "\n error during the update of a reference, the number " + << num_ancien << " in the list " + << " does not belong to the range of existing nodes [1," << nb_noeud << "] ";}; + refe->Affiche(); + Sortie(1); + }; + }; + // on supprime les doublons éventuels + refe->Supprime_doublons_internes(); + }; + }; +}; + + + + // mise à jour des références d'élément, dans le cas où les numéros d'élément ont changés +//1) cas où l'on supprime éventuellement des éléments de la référence, qui ne sont plus référencé +// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" +// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de cet élément +// = false indique qu'il continue d'être actif +void LesReferences::Mise_a_jour_ref_element(Tableau & nv_tab,int num_mail,Tableau & non_referencer) +{ bool fr = ParaGlob::Francais(); // pour simplifier + // on vérifie le numéro de maillage + if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille())) + { if (fr) {cout << "\n **** bizarre on demande de changer la numerotation d'element de reference pour le" + << " maillage numero: " << num_mail << " qui soit n'existe pas ou soit n'a pas de reference !! ";} + else {cout << "\n **** strange, we try to change the numerotation of elements belonging to a reference of a " + << " mesh number : " << num_mail << " which does not exist or does not contain any reference !! ";}; + }; + // on balaie la map + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(num_mail); + map < string, Reference*, std::less >::iterator il,ilfin = mapDeRef.end(); + + +// { int i = num_mail; +// map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); +// map < string, Reference*, std::less >::const_iterator i_map; +// if (ParaGlob::Francais()) {cout << " \n ------- affichage des listes de references ------- \n ";} +// else {cout << " \n ------- display of the lists of references ------- \n ";}; +// for (i_map=mapDeRef.begin() ; i_map != mapDeRef.end(); i_map++) +// (*i_map).second->Affiche(); +// cout << endl; +// }; + + + +// list ::const_iterator il,ilfin=listeDeRef.end(); + int nb_element = nv_tab.Taille(); + for (il=mapDeRef.begin() ; il != mapDeRef.end(); il++) + { switch((*il).second->Indic()) + {case 2: // cas où il s'agit d'une référence d'élément + { ReferenceNE* refe = ((ReferenceNE*) (*il).second); // on récupère la référence + int nb_el = refe->Taille(); + // premier passage on change les numéros + int nb_element_supprime = 0; // nombre de elements supprimés + for (int i=1; i<= nb_el; i++) + { int num_ancien = refe->Numero(i); + // on vérifie que l'élement continue d'être valide + if (non_referencer(num_ancien)) + { if (ParaGlob::NiveauImpression() > 3) + {if (fr) {cout << "\n suppression de l'element " << num_ancien << " dans la reference " + << refe->Nom() << " maillage:" << num_mail << endl;} + else {cout << "\n erasure of the element " << num_ancien << " in the reference " + << refe->Nom() << " mesh :" << num_mail << endl;}; + }; + // on commence par mettre -100 dans le tableau de num et ensuite on retassera le tableau à la fin + refe->Change_num_dans_ref(i,-100); + nb_element_supprime++; + } + else // sinon il faut le garder + { // on vérifie que le numéro de la référence est licite (normalement il doit l'être) + if ((num_ancien > 0) && (num_ancien <= nb_element)) + {refe->Change_num_dans_ref(i,nv_tab(num_ancien));} + else + {if (fr) {cout << "\n erreur dans la mise a jour d'une reference , le numero " + << num_ancien << " de la liste " + << " n'appartient pas a l'intervalle des elements disponibles [1," << nb_element << "] ";} + else {cout << "\n error during the update of a reference, the number " + << num_ancien << " in the list " + << " does not belong to the range of existing elements [1," << nb_element << "] ";}; +// debug cout << " \n non_referencer(num_ancien) " << non_referencer(num_ancien) << endl; + refe->Affiche(); + Sortie(1); + }; + }; + }; + // second passage dans le cas où l'on a supprimé des elements + if (nb_element_supprime) + { // a) on fait un décalage dans le tableau initial + int indice_new = 1; + for (int i=1; i<= nb_el; i++) + { if (refe->Numero(i) != -100) + {refe->Change_num_dans_ref(indice_new,refe->Numero(i)); + indice_new++; + }; + }; + // b) on retasse le tableau + Tableau tab_inter = refe->Tab_num(); + tab_inter.Change_taille(nb_el-nb_element_supprime); + refe->Change_tab_num(tab_inter); + }; + // on supprime les doublons éventuels + refe->Supprime_doublons_internes(); + break; + } + case 3: case 4: case 6: // cas où il s'agit d'une face ou arête ou ptint d'élément + {ReferenceAF* refe = ((ReferenceAF*) (*il).second); // on récupère la référence + // on récupère les deux tableaux de la référence + const Tableau& tab_elem = refe->Tab_Elem(); // le tableau des numeros d'éléments + //puis le tableau des numeros de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + const Tableau& tab_entite = refe->Tab_FA(); + // on va travailler avec ces tableaux et ensuite on recréra une nouvelle référence avec de nouveaux tableaux + int nb_el = tab_elem.Taille(); + // premier passage on change les numéros + int nb_element_supprime = 0; // nombre de elements supprimés + for (int i=1; i<= nb_el; i++) + { int num_ancien = refe->NumeroElem(i); + // on vérifie que le element continue d'être valide + if (non_referencer(num_ancien)) + { if (ParaGlob::NiveauImpression() > 3) + {if (fr) {cout << "\n suppression de l'element " << num_ancien << " dans la reference " + << refe->Nom() << " maillage:" << num_mail ;} + else {cout << "\n erasure of the element " << num_ancien << " in the reference " + << refe->Nom() << " mesh :" << num_mail ;}; + }; + // on commence par mettre -100 dans le tableau de num et ensuite on retassera le tableau à la fin + tab_elem(i) = -100; + nb_element_supprime++; + } + else // sinon il faut le garder + { // on vérifie que le numéro de la référence est licite (normalement il doit l'être) + if ((num_ancien > 0) && (num_ancien <= nb_element)) + {tab_elem(i) = nv_tab(num_ancien);} + // {refe->Change_num_dans_ref(i,nv_tab(num_ancien));} + else + {if (fr) {cout << "\n erreur dans la mise a jour d'une reference , le numero " + << num_ancien << " de la liste " + << " n'appartient pas a l'intervalle des elements disponibles [1," << nb_element << "] ";} + else {cout << "\n error during the update of a reference, the number " + << num_ancien << " in the list " + << " does not belong to the range of existing elements [1," << nb_element << "] ";}; +// debug cout << " \n non_referencer(num_ancien) " << non_referencer(num_ancien) << endl; + refe->Affiche(); + Sortie(1); + }; + }; + }; + // on crée deux nouveaux tableaux + Tableau tab_elem_new(nb_el-nb_element_supprime); // le nouveau tableau des numeros d'éléments + //puis le tableau des numeros de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + Tableau tab_entite_new(nb_el-nb_element_supprime); + // on va travailler avec ces tableaux et ensuite on mettra à jour la référence + // second passage dans le cas où l'on a supprimé des elements + if (nb_element_supprime) + {// on recopie les grandeurs correctes + int indice_new = 1; + for (int i=1; i<= nb_el; i++) + { if (tab_elem(i) != -100) + {tab_elem_new(indice_new)=tab_elem(i); + tab_entite_new(indice_new) = tab_entite(i); + indice_new++; + }; + }; + // on change les deux tableaux dans la référence + refe->Change_tab_num(tab_elem_new,tab_entite_new); + // on supprime les doublons éventuels + refe->Supprime_doublons_internes(); + } + else // sinon on ne fait que supprimer les doublons éventuels + {refe->Supprime_doublons_internes();}; + break; + } + + case 7: case 8: // cas où il s'agit de pti d'une face ou arête d'élément + {ReferencePtiAF* refe = ((ReferencePtiAF*) (*il).second); // on récupère la référence + // on récupère les trois tableaux de la référence + const Tableau& tab_elem = refe->Tab_Elem(); // le tableau des numeros d'éléments + //puis le tableau des numeros de faces, ou d'arêtes + const Tableau& tab_entite = refe->Tab_FA(); + // puis le tableau des pti + const Tableau& tab_entite_pti = refe->Tab_Pti(); + + // on va travailler avec ces tableaux et ensuite on recréra une nouvelle référence avec de nouveaux tableaux + int nb_el = tab_elem.Taille(); + // premier passage on change les numéros + int nb_element_supprime = 0; // nombre de elements supprimés + for (int i=1; i<= nb_el; i++) + { int num_ancien = refe->NumeroElem(i); + // on vérifie que le element continue d'être valide + if (non_referencer(num_ancien)) + { if (ParaGlob::NiveauImpression() > 3) + {if (fr) {cout << "\n suppression de l'element " << num_ancien << " dans la reference " + << refe->Nom() << " maillage:" << num_mail ;} + else {cout << "\n erasure of the element " << num_ancien << " in the reference " + << refe->Nom() << " mesh :" << num_mail ;}; + }; + // on commence par mettre -100 dans le tableau de num et ensuite on retassera le tableau à la fin + tab_elem(i) = -100; + nb_element_supprime++; + } + else // sinon il faut le garder + { // on vérifie que le numéro de la référence est licite (normalement il doit l'être) + if ((num_ancien > 0) && (num_ancien <= nb_element)) + {tab_elem(i) = nv_tab(num_ancien);} + else + {if (fr) {cout << "\n erreur dans la mise a jour d'une reference , le numero " + << num_ancien << " de la liste " + << " n'appartient pas a l'intervalle des elements disponibles [1," << nb_element << "] ";} + else {cout << "\n error during the update of a reference, the number " + << num_ancien << " in the list " + << " does not belong to the range of existing elements [1," << nb_element << "] ";}; + // debug cout << " \n non_referencer(num_ancien) " << non_referencer(num_ancien) << endl; + refe->Affiche(); + Sortie(1); + }; + }; + }; + // on crée 3 nouveaux tableaux + Tableau tab_elem_new(nb_el-nb_element_supprime); // le nouveau tableau des numeros d'éléments + //puis le tableau des numeros de faces, ou d'arêtes, + Tableau tab_entite_new(nb_el-nb_element_supprime); + //puis le tableau de points d'integ + Tableau tab_entite_pti_new(nb_el-nb_element_supprime); + // on va travailler avec ces tableaux et ensuite on mettra à jour la référence + // second passage dans le cas où l'on a supprimé des elements + if (nb_element_supprime) + {// on recopie les grandeurs correctes + int indice_new = 1; + for (int i=1; i<= nb_el; i++) + { if (tab_elem(i) != -100) + {tab_elem_new(indice_new)=tab_elem(i); + tab_entite_new(indice_new) = tab_entite(i); + tab_entite_pti_new(indice_new) = tab_entite_pti(i); + indice_new++; + }; + }; + // on change les deux tableaux dans la référence + refe->Change_tab_num(tab_elem_new,tab_entite_new,tab_entite_pti_new); + // on supprime les doublons éventuels + refe->Supprime_doublons_internes(); + } + else // sinon on ne fait que supprimer les doublons éventuels + {refe->Supprime_doublons_internes();}; + break; + } + + + }; + }; +}; + + +// suppression d'une référence +void LesReferences::SupprimeReference(const string & st1,int num_mail) + { bool fr = ParaGlob::Francais(); // pour simplifier + // tout d'abord on cherche la référence + if (num_mail > t_mapDeRef.Taille()) + { if (fr) {cout << " \n pb1 la reference de nom " << st1 << " pour le maillage nb= "<< num_mail + << " n\'existe pas !! , on ne peut pas la supprimer " << endl;} + else {cout << " \n pb1 the reference with name " << st1 << " for the mesh number= "<< num_mail + << " does not exist !! , we cannot erase it " << endl;}; + if (ParaGlob::NiveauImpression() >= 5) + cout << "\n LesReferences::SupprimeReference(..."; + Sortie (1); + }; + map < string, Reference*, std::less >::iterator il = t_mapDeRef(num_mail).find(st1); + if (il == t_mapDeRef(num_mail).end()) + { if (fr) {cout << " \n pb2 la reference de nom " << st1 << " pour le maillage nb= "<< num_mail + << " n\'existe pas !! , on ne peut pas la supprimer " << endl;} + else {cout << " \n pb2 the reference with name " << st1 << " for the mesh number= "<< num_mail + << " does not exist !! , we cannot erase it " << endl;}; + if (ParaGlob::NiveauImpression() >= 5) + cout << "\n LesReferences::SupprimeReference(..."; + Sortie (1); + } + else // sinon c'est ok + { // on commence par effacer la référence + if ((*il).second != NULL) {delete (*il).second;(*il).second=NULL;}; + // puis on le suprime du tableau de map + t_mapDeRef(num_mail).erase(il); + }; + }; + + // suppression de tous les référence d'un maillage donné + // si avec_diminution_num_maillage = true: + // tous les numéros de maillage, > num_mail, associé aux maillages qui restent + // sont diminués de un, pour tenir compte de la disparition du maillage et donc + // d'une nouvelle numérotation des maillages + // si avec_diminution_num_maillage = false, le conteneur des ref de maillage num_mail + // est vidé, mais il continu à exister: on considère qu'il y a toujours un maillage num_mail potentiel +void LesReferences::Supprime_tour_lesRef_un_maillage(int num_mail, bool avec_diminution_num_maillage) +{// bien que nbMaille ne serve pas a priori sans être initialisé + // , pour éviter qu'il soit inchoérent, on le modifie éventuellement + if (nbMaille > num_mail) + {nbMaille = 1; // par défaut + indic = 1; // toujours par défaut + }; + // on met à jour la t_mapDeRef + map < string, Reference*, std::less >::iterator il,ilfin; + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(num_mail); + // vérif + int tai=t_mapDeRef.Taille(); + if (num_mail <1) + { cout << "\n erreur, impossible de supprimer les ref du maillage "< tai) // pas de référence enregistrées pour ce maillage + // on ne fait rien et on revient + return; + // on supprime les ref + ilfin = mapDeRef.end(); + for (il = mapDeRef.begin();il != ilfin; il++) + delete (*il).second; + // suppression ou non du conteneur + if (avec_diminution_num_maillage) + { // on retasse le tableau + for (int i=num_mail;i<=tai-1;i++) + {t_mapDeRef(i)=t_mapDeRef(i+1); + // on change les numéros de maillages + map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i ); + ilfin = mapDeRef.end(); + for (il = mapDeRef.begin();il != ilfin; il++) + (*il).second->Change_Nbmaille(i); + }; + // le fait de changer de taille supprime l'élément tai + t_mapDeRef.Change_taille(tai-1); + nbMaille--; // on diminue le nombre de maillage en service pour les ref + }; +}; + + +//----- lecture écriture de base info ----- +// lecture base info +// = 1 : on récupère tout +// = 2 : on récupère uniquement les données variables (supposées comme telles) +void LesReferences::Lecture_base_info(ifstream& entr,const int cas) + {bool fr = ParaGlob::Francais(); // pour simplifier + // pour l'instant nous n'avons que des références fixes + if (cas == 1) + {if (fr) {cout << " == lecture des references \n";} + else {cout << " == reading of the references \n";}; + // on commence par effacer les références existantes + int taille = t_mapDeRef.Taille(); + for (int i=1;i<=taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + map < string, Reference*, std::less >::iterator il,ilfin = mapDeRef.end(); + for (il=mapDeRef.begin() ; il != ilfin; il++) + if ((*il).second != NULL) {delete (*il).second;(*il).second=NULL;}; + mapDeRef.erase(mapDeRef.begin(),mapDeRef.end()); + }; + // on lit et dimensionne le tableau + string toto;int t_taille; + entr >> toto >> t_taille ; + t_mapDeRef.Change_taille(t_taille); + for (int i=1;i<=t_taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + int nb_ref=0; + entr >> toto >> nb_ref; + // on boucle sur le nombre de référence à lire + int indic; + for (int i=1;i<= nb_ref; i++) + { // lecture du type de référence + entr >> toto >> indic; + // création d'une référence ad hoc + int nbMaille = -10; + switch (indic) + {// le numéro de maillage est mis en négatif pour indiquer qu'il est faux + // il est ensuite lue à la bonne valeur par la référence + case 1 : ref = new ReferenceNE(nbMaille,indic); break; + case 2 : ref = new ReferenceNE(nbMaille,indic); break; + case 3 : ref = new ReferenceAF(nbMaille,indic); break; + case 4 : ref = new ReferenceAF(nbMaille,indic); break; + case 5 : ref = new ReferenceAF(nbMaille,indic); break; + case 6 : ref = new ReferenceAF(nbMaille,indic); break; + case 7 : ref = new ReferencePtiAF(nbMaille,indic); break; + case 8 : ref = new ReferencePtiAF(nbMaille,indic); break; + default : + if (fr) {cout << "\nErreur : valeur incorrecte du type de reference indic = " << indic << "\n";} + else {cout << "\nError : incorrect value of the type of reference indic = " << indic << "\n";}; + cout << "LesReferences::Lecture_base_info(..." ; + Sortie(1); + }; + // lecture de la référence en question + ref->Lecture_base_info(entr,cas); + // intégration dans la map + mapDeRef[ref->Nom()]=ref; + }; + }; + }; + }; + + + +// écriture base info +// = 1 : on sauvegarde tout +// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) +void LesReferences::Ecriture_base_info(ofstream& sort,const int cas) + {bool fr = ParaGlob::Francais(); // pour simplifier + // pour l'instant nous n'avons que des références fixes + if (cas == 1) + {int t_taille = t_mapDeRef.Taille(); + if (fr) {sort << "\n ****taille_tableau_references= " << t_taille << " ";} + else {sort << "\n ****size_tab_references= " << t_taille << " ";}; + for (int i=1;i<=t_taille;i++) + { map < string, Reference*, std::less >& mapDeRef = t_mapDeRef(i); + map < string, Reference*, std::less >::iterator il,ilfin=mapDeRef.end(); + if (fr) {sort << "\n ****les_references_du_maillage"<LectureReference(entreePrinc)); + // on supprime les doublons éventuels + ref->Supprime_doublons_internes(); + return retour; + }; + + +// retourne la reference correspondant a une cle +Reference& LesReferences::Trouve_interne(const string & st1,int num_mail) const +{ if (num_mail > t_mapDeRef.Taille()) + { if (ParaGlob::Francais()) + {cout << " \n pb la reference de nom " << st1 << " pour le maillage nb= "<< num_mail << " n'existe pas \n";} + else {cout << "\nError : the reference with the name " << st1 << " for the mesh nb= " << num_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + { cout << " \n LesReferences::Trouve(const string & st1,int num_mail) " << endl;}; + Sortie (1); + } + else if (t_mapDeRef(num_mail).find(st1) == t_mapDeRef(num_mail).end()) + { if (ParaGlob::Francais()) + {cout << " \n pb la reference de nom " << st1 << " pour le maillage nb= "<< num_mail << " n'existe pas \n";} + else {cout << "\nError : the reference with the name " << st1 << " for the mesh nb= " << num_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + { cout << " \n LesReferences::Trouve(const string & st1,int num_mail) " << endl;}; + Sortie (1); + }; + // sinon c'est ok + return *(t_mapDeRef(num_mail)[st1]); +}; + +// idem mais avec un nom de maillage +Reference& LesReferences::Trouve_interne(const string & st1,const string* nom_mail) const +{ // on regarde si le nom de maillage est licite + if (nom_mail == NULL) + { // acceptable que si l'on a un seul maillage + #ifdef MISE_AU_POINT + if (listeNomMail->size() != 1) + if (ParaGlob::NiveauImpression() >2) + { if (ParaGlob::Francais()) + {cout << "\n warning: la reference demandee= " << st1 << " , n'a pas de nom de maillage associe" + << " alors qu'il y a plusieurs maillage defini !! : on considere que c'est une ref du premier maillage";} + else {cout << "\n warning: the wanted reference " << st1 << " , has no associated mesh " + << " but several meshes exist !! : we consider that it is a ref for the first mesh ";} + if (ParaGlob::NiveauImpression() >5) + { if (ParaGlob::Francais()) {cout << "\n nom_de_maillages= ";} + else {cout << "\n names of the meshes = ";} + map < string, int , std::less >::const_iterator ili,ilifin=listeNomMail->end(); + for (ili = listeNomMail->begin();ili != ilifin; ili++) + cout << (*ili).first << ", " ; + cout << "\n LesReferences::Trouve_interne(const string & st1,const string& nom_mail) "; + }; +// Sortie(1); + }; + #endif + // on ramène le cas du premier maillage qui doit exister + return Trouve_interne(st1,1); + } + else + { + #ifdef MISE_AU_POINT + // on regarde si le nom de maillage existe dans la liste + if (listeNomMail->find(*nom_mail) == listeNomMail->end()) + { if (ParaGlob::Francais()) {cout << "\nErreur : le nom de maillage : " << *nom_mail << " n'existe pas \n";} + else {cout << "\nError : the name of the mesh : " << *nom_mail << " does not exist \n";} + if (ParaGlob::NiveauImpression() >5) + cout << "LesReferences::Trouve_interne(const string & st1,const string& nom_mail) \n"; + Sortie(1); + } + #endif + return Trouve_interne(st1,(*(listeNomMail->find(*nom_mail))).second); + }; +}; + diff --git a/References/LesReferences.h b/References/LesReferences.h new file mode 100644 index 0000000..71e1f7c --- /dev/null +++ b/References/LesReferences.h @@ -0,0 +1,204 @@ +/************************************************************************ + * UNIVERSITE DE BRETAGNE SUD --- I.U.P/I.U.T. DE LORIENT * + ************************************************************************ + * LABORATOIRE DE GENIE MECANIQUE ET MATERIAUX * + * Tel 97.80.80.60 * + * Centre de Genie Industriel 56520 GUIDEL-PLAGES * + ************************************************************************ + * DATE: 23/01/97 * + * $ * + * AUTEUR: G RIO * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: Gestion des listes de references. * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ +#ifndef LESREFERENCES_H +#define LESREFERENCES_H + +#include "Reference.h" +#include +#include +#include "UtilLecture.h" +#include "MotCle.h" + +//-------- une méthode permettant d'utiliser des tableaux de map de références ----- + // surcharge de l'operator d'ecriture + ostream & operator << (ostream & sort, const map < string, Reference*, std::less > & ); + +//----------- fin de la méthode permettant d'utiliser des tableaux de map de références ----- + +class LesReferences +{ + public : + // CONSTRUCTEURS : + LesReferences (); // par defaut + // DESTRUCTEUR : + ~LesReferences (); + // METHODES PUBLIQUES : + + // def du numero de maillage courant, utilise avant la lecture + void NbMaille(int nb); + // def du type de reference a lire, utilise avant la lecture + // type peut-être : noeud,element,surface,arete + void Indic(string type); + + // lecture des references + void Lecture(UtilLecture & entreePrinc); + + // ajout d'une référence déjà construite par ailleurs + void Ajout_reference(Reference * refi); + + // suppression d'une référence + void SupprimeReference(const string & st1,int num_mail); + // suppression de tous les référence d'un maillage donné + // si avec_diminution_num_maillage = true: + // tous les numéros de maillage, > num_mail, associé aux maillages qui restent + // sont diminués de un, pour tenir compte de la disparition du maillage et donc + // d'une nouvelle numérotation des maillages + // si avec_diminution_num_maillage = false, le conteneur des ref de maillage num_mail + // est vidé, mais il continu à exister: on considère qu'il y a toujours un maillage num_mail potentiel + void Supprime_tour_lesRef_un_maillage(int num_mail, bool avec_diminution_num_maillage); + + // affichage des informations contenu dans les references + // par défaut affiche toutes les infos + // si niveau = 1 : affiche que les noms des ref + void Affiche(int niveau=0) const ; + + // affichage des informations contenu dans les references d'un certain type + // défini par indic : + // indic = 1 -> noeud, =2 -> element + // =3 -> surface associée à un élément , =4 -> arete associée à un élément + // =5 -> noeud associée à un élément + // =6 -> point d'intégration associée à un élément + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arete d'éléments + // =0 -> rien_actuellement + // par défaut affiche toutes les infos + // si niveau = 1 : affiche que les noms des ref + void Affiche(int indic, int niveau) const ; + + // Affiche les donnees des références pour le maillage imail dans un fichier + // dont le nom est construit à partir du nom du maillage au format ".lis" + void Affiche_dans_lis(const string& nom_maillage,int imail); + + // affichage et definition interactive des commandes + // nbMaxiNoeud: nombre maxi de noeud pour les exemples + // nbMaxiElem : nombre maxi d'éléments pour les exemples + // cas : =1 premier passage, il s'agit de références de noeuds uniquement + // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références + void Info_commande_lesRef(int nbMaxiNoeud,int nbMaxiElem,UtilLecture * entreePrinc,int cas); + + //--- utilisation d'une boucle pour balayer l'ensemble des références existantes: + // ***** très important: ce balaiyage ne fonctionne que si on ne modifie pas le stockage + // ***** par exemple en supprimant une référence existante ou en ajoutant une nouvelle référence + // ***** ou en lisant des références (donc ajout !!) + // ***** par contre on peut changer le contenu des références existantes + // initialise le questionnement de la récupération de référence et + // retourne la première référence si elle existe sinon un pointeur nul + const Reference* Init_et_Premiere(); + // retourne la référence suivante ou, s'il n'y en n'a plus, retourne + // un pointeur nul + const Reference* Reference_suivante(); + //--- fin méthode pour faire une boucle pour balayer l'ensemble des références existantes: + + // test si la reference existe reellement + // retourne false si n'existe pas , true sinon + bool Existe(const string & st1,int num_mail) const ; + bool Existe(const string & st1,const string* nom_mail) const; + // retourne la reference correspondant a une cle + const Reference& Trouve(const string & st1,int num_mail) const ; + const Reference& Trouve(const string & st1,const string* nom_mail) const ; + // mise à jour de la map qui fait la liaison nom de maillage <=> numéro de maillage + void MiseAJourMap( const map < string, int , std::less >& listNomMail) + { listeNomMail = & listNomMail;}; + + // mise à jour des références de noeud, dans le cas où les numéros de noeuds ont changés +//1) cas où l'on supprime éventuellement des noeuds de la référence, qui ne sont plus référencé + // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" + // non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de ce noeud + // = false indique qu'il continue d'être actif + void Mise_a_jour_ref_noeud(Tableau & nv_tab,int num_mail,Tableau & non_referencer); +//2) cas où on considère tous les noeuds + // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" + void Mise_a_jour_ref_noeud(Tableau & nv_tab,int num_mail); + + // mise à jour des références d'élément, dans le cas où les numéros d'élément ont changés +//1) cas où l'on supprime éventuellement des éléments de la référence, qui ne sont plus référencé + // nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i" + // non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de cet élément + // = false indique qu'il continue d'être actif + void Mise_a_jour_ref_element(Tableau & nv_tab,int num_mail,Tableau & non_referencer); + + // mise à jour du numéro de maillage d'une référence + void Mise_a_jour_num_maillage_ref(const string nom_ref, int old_num_maill, int new_num_maill) + { Trouve_interne(nom_ref,old_num_maill).Change_Nbmaille(new_num_maill);}; + + //----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + void Lecture_base_info(ifstream& ent,const int cas); + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + void Ecriture_base_info(ofstream& sort,const int cas); + + protected : + // variable transitoires utilise pendant la lecture + int nbMaille; // nb courant de maillage + int indic ; // type courant de reference : = 1 -> noeud, =2 -> element + // =3 -> surface associée à un élément , =4 -> arete associée à un élément + // =5 -> noeud associée à un élément + // =6 -> point d'intégration associée à un élément + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + // =0 -> rien_actuellement + Reference * ref; // une variable de travail + + // VARIABLES PROTEGEES : +// list listeDeRef; // liste des references + + // on utilise une map pour récupérer plus rapidemment une référence à partir d'un nom + // t_mapDeRef (i) est la map relative au maillage i + Tableau < map < string, Reference*, std::less > > t_mapDeRef; + + + + // liste des noms de maillages associée à un numéro sous forme d'un arbre pour faciliter la recherche + const map < string, int , std::less >* listeNomMail; + // a utiliser avec Existe et Trouve, mais pas avant la lecture, seulement après + + static MotCle motCle; // liste des mots clés + + //list ::const_iterator iref; + // deux variables intermédiaires pour les méthodes Init_et_Premiere et Reference_suivante + map < string, Reference*, std::less >::const_iterator iref; + int num_mail_presuivant; + + + // METHODES PROTEGEES : + // lecture d'une reference + bool LectureReference(UtilLecture & entreePrinc); + // retourne la reference correspondant a une cle, en non constant + Reference& Trouve_interne(const string & st1,int num_mail) const ; + Reference& Trouve_interne(const string & st1,const string* nom_mail) const ; + + + }; + +#endif diff --git a/References/Reference.cc b/References/Reference.cc new file mode 100644 index 0000000..8056cc5 --- /dev/null +++ b/References/Reference.cc @@ -0,0 +1,125 @@ +// FICHIER : Reference.cp +// CLASSE : Reference + + +#include "Reference.h" + +#ifndef REFERENCE_H_deja_inclus + +// --------------- variables statiques --------- +// déclaré dans Reference_static.cp +//MotCle Reference::motCle; // liste des mots clés // finalement déclaré ici ! + +#ifndef MISE_AU_POINT + inline +#endif +Reference::Reference (string nom): +// Constructeur par defaut (appel au constructeur par defaut de Tableau) + nom_ref(nom),nbmaille(0),indic(0) +{ }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction du nb de maillage et du type de ref +Reference::Reference (int nb , int ind) : + nbmaille(nb),indic(ind),nom_ref("aucun nom") + { }; + +#ifndef MISE_AU_POINT + inline +#endif +Reference::Reference (string nom,int nb , int ind) : +// Constructeur utile si le nom de la reference est connu + nom_ref(nom),nbmaille(nb),indic(ind) +{ }; + + +#ifndef MISE_AU_POINT + inline +#endif +Reference::Reference (const Reference& ref): +// Constructeur de copie + nom_ref(ref.nom_ref),nbmaille(ref.nbmaille),indic(ref.indic) +{ }; + +#ifndef MISE_AU_POINT + inline +#endif +Reference::~Reference () +// Destructeur +{ }; + + // METHODES : + +// Surcharge de l'operateur = : realise l'egalite entre deux references +#ifndef MISE_AU_POINT + inline +#endif +Reference& Reference::operator= (const Reference& ref) + { indic = ref.indic; + nbmaille = ref.nbmaille; + nom_ref = ref.nom_ref; + return (*this); + }; + +// Retourne le nom associe a la reference +#ifndef MISE_AU_POINT + inline +#endif + string Reference::Nom () const + { return nom_ref; }; + +// Retourne le type de reference +#ifndef MISE_AU_POINT + inline +#endif +int Reference::Indic () const + { return indic; }; + +// Retourne le numero du maillage auquelle la reference se rattache +#ifndef MISE_AU_POINT + inline +#endif +int Reference::Nbmaille() const + { return nbmaille; }; + + +// Remplace l'ancien nom de la reference par nouveau_nom +#ifndef MISE_AU_POINT + inline +#endif +void Reference::Change_nom (string nouveau_nom) + { nom_ref = nouveau_nom; }; + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +void Reference::Affiche () const + { cout << "\nNom de la reference : " << nom_ref + << " , maillage nb =" << nbmaille << ", de type = " << indic << '\n'; + }; + + +// methodes appellées par les classes dérivées + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void Reference::Lect_int_base_info(ifstream& ent) + { string toto; + ent >> nom_ref >> nbmaille ; }; + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void Reference::Ecrit_int_base_info(ofstream& sort) + { sort << nom_ref <<" " << nbmaille << " "; }; + + +#endif diff --git a/References/Reference.h b/References/Reference.h new file mode 100644 index 0000000..ecc09a9 --- /dev/null +++ b/References/Reference.h @@ -0,0 +1,176 @@ +// FICHIER : Reference.h +// CLASSE : Reference +/************************************************************************ + * UNIVERSITE DE BRETAGNE SUD (UBS) --- I.U.P/I.U.T. DE LORIENT * + ************************************************************************ + * LABORATOIRE DE GENIE MECANIQUE ET MATERIAUX (LG2M) * + * Centre de Recherche Bvd Flandres Dunkerque - 56325 Lorient Cedex * + * tel. 02.97.87.45.70 fax. 02.97.87.45.72 http://www-lg2m.univ-ubs.fr * + ************************************************************************ + * DATE: 06/02/00 * + * $ * + * AUTEUR: G RIO (mailto:gerard.rio@univ-ubs.fr) * + * Tel 0297874571 fax : 02.97.87.45.72 * + * $ * + * PROJET: Herezh++ * + * $ * + ************************************************************************ + * BUT: classe général virtuel des références. Les classes dérivées* + * permettent de définir précisemment les différentes références : * + * de noeuds, d'élément, d'aretes, de faces etc.. * + * Une instance de la classe s'identifie a partir d'un nom * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * + * VERIFICATION: * + * * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * ! ! ! ! * + * $ * + * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * + * MODIFICATIONS: * + * ! date ! auteur ! but ! * + * ------------------------------------------------------------ * + * $ * + ************************************************************************/ + + +#ifndef REFERENCE_H +#define REFERENCE_H + + +#include +#include +//#include "Debug.h" +#include "Tableau_T.h" +#include "UtilLecture.h" +#include +#include "MotCle.h" + +class Reference +{ + public : + + // CONSTRUCTEURS : + + // Constructeur par defaut + Reference ( string nom = "rien_actuellement"); + + // indic = 1 : il s'agit de reference de noeud + // indic = 2 : il s'agit de reference d'element + // =3 -> surface relatives à des éléments, + // =4 -> arrete relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + + // Constructeur fonction du nb de maillage et du type de ref + Reference (int nbmaille , int indic); + + // Constructeur fonction d'un nom de reference + // du nb de maillage, du type de ref + Reference (string nom,int nbmaille , int indic); + + // Constructeur de copie + Reference (const Reference& ref); + + + // DESTRUCTEUR : + + virtual ~Reference (); + + + // METHODES : + + // création d'une référence du même type contenant les mêmes info + // que la référence donnée en argument: utilisation du constructeur de copie + virtual Reference* Nevez_Ref_copie() const = 0; + + // Surcharge de l'operateur = : realise l'egalite entre deux references + virtual Reference& operator= (const Reference& ref); + + // Retourne le nom associe a la reference + string Nom () const; + + // Retourne le type de reference + // = 1 : il s'agit de reference de noeud + // = 2 : il s'agit de reference d'element + // =3 -> surface relatives à des éléments, + // =4 -> arrete relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + int Indic () const; + + // Retourne le numero du maillage auquelle la reference se rattache + int Nbmaille() const; + // change le numéro du maillage associé + void Change_Nbmaille(int nv_nm) {nbmaille= nv_nm;}; + + // Remplace l'ancien nom de la reference par nouveau_nom + void Change_nom (string nouveau_nom); + + // supprime les doublons internes éventuels dans la référence + virtual void Supprime_doublons_internes() = 0; + + // Affiche les donnees liees a la reference + virtual void Affiche () const; + + // Affiche les donnees des références dans le flux passé en paramètre + virtual void Affiche_dans_lis(ofstream& sort) const =0 ; + + // lecture d'une liste de reference + virtual bool LectureReference(UtilLecture & entreePrinc) =0 ; + + // affichage et definition interactive des commandes + // nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples + // cas : =1 premier passage, il s'agit de références de noeuds uniquement + // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références + virtual void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) =0; + + //----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + virtual void Lecture_base_info(ifstream& ent,const int cas) =0; + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + virtual void Ecriture_base_info(ofstream& sort,const int cas) =0; + + protected : + + string nom_ref; // nom de la reference + int nbmaille; // numero du maillage auquelle la reference se rapporte + int indic; // indic = 1 : il s'agit de reference de noeud + // indic = 2 : il s'agit de reference d'element + // =3 -> surface relatives à des éléments, + // =4 -> arrete relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + static MotCle motCle; // liste des mots clés + + // methodes appellées par les classes dérivées + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + void Lect_int_base_info(ifstream& ent); + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + void Ecrit_int_base_info(ofstream& sort); + +}; + +#ifndef MISE_AU_POINT + #include "Reference.cc" + #define REFERENCE_H_deja_inclus +#endif + +#endif + + diff --git a/References/ReferenceAF.cc b/References/ReferenceAF.cc new file mode 100644 index 0000000..99dc4c3 --- /dev/null +++ b/References/ReferenceAF.cc @@ -0,0 +1,554 @@ +// FICHIER : ReferenceAF.cp +// CLASSE : ReferenceAF + + +#include "ReferenceAF.h" +#include "PtTabRel.h" + +#ifndef REFERENCEAF_H_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur par defaut (appel au constructeur par defaut de Tableau) +ReferenceAF::ReferenceAF (string nom): + Reference(nom),tab_Elem(),tab_FA() + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction du nb de maillage et du type de ref +ReferenceAF::ReferenceAF (int nb , int ind) : + Reference(nb,ind),tab_Elem(),tab_FA() + { }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction de deux tableaux de numeros, le premier pour les numéros +// d'éléments le second pour les numéros de faces, d'aretes, de noeud d'element, ou de point d'integ +// du nb de maillage, du type de ref +ReferenceAF::ReferenceAF (const Tableau& tabelem,const Tableau& tab + ,int nbmaille , int indic, string nom): + Reference(nom,nbmaille,indic),tab_Elem(tabelem),tab_FA(tab) + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction de deux listes de numeros, la première pour les numéros +// d'éléments la seconde pour les numéros de faces, d'aretes, de noeud d'element, ou de point d'integ +// du nb de maillage, du type de ref +ReferenceAF::ReferenceAF (const list & list_elem,const list & list_num + ,int nbmaille , int indic, string nom): + Reference(nom,nbmaille,indic),tab_Elem(list_elem.size()),tab_FA(list_num.size()) + { int tail = tab_Elem.Taille(); + list ::const_iterator it=list_elem.begin(); + for (int i=1;i<= tail;i++,it++) + tab_Elem(i)=(*it); + tail = tab_FA.Taille(); it = list_num.begin(); + for (int i=1;i<= tail;i++,it++) + tab_FA(i)=(*it); + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur utile si le nom de la reference est connu +ReferenceAF::ReferenceAF (string nom,int nb , int ind) : + Reference(nom,nb,ind),tab_Elem(),tab_FA() + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur de copie +ReferenceAF::ReferenceAF (const ReferenceAF& ref): + Reference (ref),tab_Elem(ref.tab_Elem),tab_FA(ref.tab_FA) + { }; + +// Destructeur +#ifndef MISE_AU_POINT + inline +#endif +ReferenceAF::~ReferenceAF () + { }; + +//================== METHODES : ================================ + +#ifndef MISE_AU_POINT + inline +#endif +Reference& ReferenceAF::operator= (const Reference& ref) + { *this = this->Reference::operator=(ref); // pour la partie de la classe mère + #ifdef MISE_AU_POINT + // vérification du type de ref + if ((ref.Indic() != 3) && (ref.Indic() != 4)&& (ref.Indic() != 5)&& (ref.Indic() != 6)) + {if (ParaGlob::Francais()) + {cout << " \n erreur dans l'affectation de reference : ReferenceAF::operator= (const Reference& ref)" + << "\n la reference ref n'est ni celle de face, d'arete, de noeud d'element " + << " ou de pt d'integ "; + } + else + {cout << " \n error in the operator of reference : ReferenceAF::operator= (const Reference& ref)" + << "\n the reference ref is not a reference of a face, an edge, a node " + << " or a gauss point "; + }; + }; + #endif + tab_Elem = ((ReferenceAF&) ref).tab_Elem; + tab_FA = ((ReferenceAF&) ref).tab_FA; + return (*this); + }; + + + +// change un numéro i de référence +// nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, ou de noeud d'element, +// ou de points d'integ +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Change_num_AF_dans_ref(int i,int nbe, int nbAF) + { if ((i < 1)|| (i>tab_Elem.Taille())) + { cout << "\n *** erreur de changement de numero dans la reference : " << this->Nom() + << "\n le numero demande est le " << i << " ce qui est en dehors des valeurs possibles " + << " qui doivent etre comprises entre 1 et "<Affiche(); + Sortie(1); + }; + tab_Elem(i)=nbe;tab_FA(i)= nbAF; + }; + +// change les 2 tableaux de la ref +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Change_tab_num(const Tableau& tabele,const Tableau& tab) + { // on vérifie que les deux tableaux ont la même taille + if (tabele.Taille() != tab.Taille()) + { cout << "\n *** erreur de changement des deux tableaux dans la reference : " << this->Nom() + << "\n les tailles des deux tableaux sont differentes: taille des elements="<< tabele.Taille() + << ", taille du second tableau =" << tab.Taille() << " on affiche la ref actuelle : "; + this->Affiche(); + Sortie(1); + }; + tab_Elem=tabele; + tab_FA= tab; + }; + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +// indique si le numéro d'élément et le numéro de faces, d'arête ou de noeud d'élément +// ou de pt d'integ passé en argument, fait partie de la référence +// nbe: le numéro d'élément, nbAF: le numéro de face, d'arête, de noeud d'element ou de pt d'integ +bool ReferenceAF::Contient_AF(int nbe, int nbAF) const + { int tail_tab=tab_Elem.Taille(); + for (int i=1;i<= tail_tab;i++) + if ((tab_Elem(i)==nbe) && (tab_FA(i)==nbAF)) return true; + return false; + }; + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Affiche () const + { // affichage du type de référence + if (indic == 3) + { if (ParaGlob::Francais()) {cout << "\n reference de face d'element";} + else {cout << "\n reference of an element face ";};} + else if (indic == 4) + { if (ParaGlob::Francais()) {cout << "\n reference d'arete d'element";} + else {cout << "\n reference of an element edge ";};} + else if (indic == 5) + { if (ParaGlob::Francais()) {cout << "\n reference de noeud d'element";} + else {cout << "\n reference of node ";};} + else if (indic == 6) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ d'element";} + else {cout << "\n reference of a gauss point ";};} + else if (indic == 7) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ relatif a une face d'element";} + else {cout << "\n reference of a gauss point for a facet of an element ";};} + else if (indic == 8) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ relatif a une arete d'element";} + else {cout << "\n reference of a gauss point for an edge of an element";};} + else + { if (ParaGlob::Francais()) {cout << "\n reference de type non defini ";} + else {cout << "\n reference not defined ";};} + // affichage pour la partie de la classe mère + this->Reference::Affiche(); + // partie spécifique + if (ParaGlob::Francais()) {cout << "Taille des tableaux : " ;} + else {cout << "size of the tab : " ;}; + cout << tab_Elem.Taille() << " .\n"; + if (ParaGlob::Francais()) + {cout << "Composante(s) (1 element puis une face ou arete ou noeud ou pt integ ):\n\t[ ";} + else + {cout << "Components(s) (1 element then one face or edge or node or gauss point ):\n\t[ ";}; + for (int i=1;i<=tab_Elem.Taille();i++) + cout << tab_Elem(i) << " "<< tab_FA(i) << " "; + cout << "]\n\n"; + }; + +// supprime les doublons internes éventuels dans la référence +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Supprime_doublons_internes() +{ //Tableau tab_Elem; // tableau des numeros des éléments de la reference + //Tableau tab_FA; // tableau des numeros des faces ou arêtes de la reference + // ou noeud d'element, ou de points d'intégrations d'élément + int taille = tab_Elem.Taille(); + list agarder; // contiendra les seules numéros à sauvegarder + for (int i=1;i<=taille;i++) + { bool bon=true; + for (int j=i+1;j<=taille;j++) + if ((tab_Elem(i)==tab_Elem(j))&& (tab_FA(i)==tab_FA(j))) + {bon=false; + if (ParaGlob::NiveauImpression() > 3) + { cout << "\n *** attention suppression doublon: ref "<::iterator ili,ilifin = agarder.end(); + int position=1; + for (ili=agarder.begin();ili!=ilifin;ili++,position++) + {tab_Elem(position) = tab_Elem(*ili); //position est toujours < *ili donc on écrase a partir du bas + tab_FA(position) = tab_FA(*ili); // et tab_Elem(*ili) et tab_FA(*ili) sont toujours valides + }; + // on supprime les données de new_taille à taille + tab_Elem.Change_taille(new_taille); + tab_FA.Change_taille(new_taille); + }; +}; + +// lecture d'une liste de references pt d'integ, ou de noeud, ou arêtes ou faces d'éléments +#ifndef MISE_AU_POINT + inline +#endif +bool ReferenceAF::LectureReference(UtilLecture & entreePrinc) + { *(entreePrinc.entree) >> nom_ref; // lecture d'une reference + // si l'on est à la fin de la ligne on passe à la ligne suivante + //cout << "\n rdstate " << entreePrinc.entree->rdstate() << endl; + if ((entreePrinc.entree->eof() != 0) && (!(entreePrinc.entree->fail()))) + { entreePrinc.NouvelleDonnee(); } + // on utilise une liste pour la lecture, ce qui permet de lire une nombre quelconque + // de numéros attachés à une référence + list inter; // on utilise des réels car c'est déjà défini par ailleurs + // mais cela n'a aucune importance sur le traitement + int il; + + if ((entreePrinc.entree->rdstate() != 0) + && (!motCle.SimotCle(entreePrinc.tablcar))) + // si le buffer ne contiend pas de mot cle et qu'il y a un + // pb de lecture ( donc pas de def de reference) + { if (ParaGlob::Francais()) + {cout << " \n Erreur de lecture de reference \n contenu du buffer = ";} + else {cout << " \n Error of reference reading \n buffer = ";}; + cout << entreePrinc.tablcar << endl; + if (ParaGlob::Francais()) + {entreePrinc.MessageBuffer + ("lecture d une reference de face ou d'arete ou de noeud d'element ou de pt d'integ"); } + else + {entreePrinc.MessageBuffer + ("reading of a reference of face or edge or node or gauss point "); }; + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie (1); + } + else if (motCle.SimotCle(entreePrinc.tablcar)) + { // fin de la lecture de reference + // remise correcte du flot + entreePrinc.FlotDebutDonnee(); + return false; + } + else + { + // cas ou on a bien lu un nom de reference + { + il = 0; // nb de nb d'entier lu + bool fin = false; + // les deux cas qui font sortir de la boucle sont l'apparition + // d'un mot cle ou une erreur en lecture dans entier + // apres une bonne lecture sur la meme ligne + bool aumoinsune = true; + bool prem = true; // ne sert que pour le cas d'une reference sans numero + while ( (!fin) & aumoinsune) + {aumoinsune = false; + // def du maillon à lire dans la liste + Reels2 as1; + // while (!entreePrinc.entree->rdstate()) // lecture tant qu'il n'y a pas d'erreur + while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur + (!(entreePrinc.entree->eof()))) + { // lecture de deux entiers mis dans deux réels + *(entreePrinc.entree) >> as1.donnees[0] ; + // si jamais on est à la fin d'une ligne on passe à la ligne suivante + if (entreePrinc.entree->eof()) + { + #ifdef ENLINUX + if (!(entreePrinc.entree->bad())) + // on continue que si le flot est correcte car en linux il s'apperçoit du pb + // qu'après la mauvaise lecture, c'est-à-dire eof() ne fonctionne pas correctement + { break; } + #endif + /* #ifdef SYSTEM_MAC_OS_X_unix + if (!(entreePrinc.entree->bad())) + // on continue que si le flot est correcte car en linux il s'apperçoit du pb + // qu'après la mauvaise lecture, c'est-à-dire eof() ne fonctionne pas correctement + { break; } + #endif */ + entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + } + *(entreePrinc.entree) >> as1.donnees[1]; + // pour la verif + // pour mémoire ici on a + /* enum io_state + { badbit = 1<<0, // -> 1 dans rdstate() + eofbit = 1<<1, // -> 2 + failbit = 1<<2, // -> 4 + goodbit = 0 // -> O + };*/ +// if ((entreePrinc.entree->rdstate() == 0)|| +// (entreePrinc.entree->eof() )) + #ifdef ENLINUX + if (entreePrinc.entree->rdstate() == 0) + #else + /* #ifdef SYSTEM_MAC_OS_X_unix + if (entreePrinc.entree->rdstate() == 0) + #else*/ + if (((entreePrinc.entree->rdstate() == 0)|| + (entreePrinc.entree->eof()))&&(!(entreePrinc.entree->bad())) + &&(!(entreePrinc.entree->fail()))) + // #endif + #endif + {il++; + aumoinsune = true; + prem = false; + inter.push_back(as1); + } + } + + if ((aumoinsune) || prem ) + {entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + if (motCle.SimotCle(entreePrinc.tablcar)) + // c'est un mot cle + fin = true; + } + else + // remise correcte du flot pour la lecture + //d'une prochaine reference + entreePrinc.FlotDebutDonnee(); + } + if (il == 0 ) + { if (ParaGlob::Francais()) {cout << "\n WARNING : aucun numero attache a la reference = ";} + else {cout << "\n WARNING : no number linked to the reference = ";}; + cout << nom_ref << endl; + } + // transfert dans les tableaux + tab_Elem.Change_taille(il); + tab_FA.Change_taille(il); + listdouble2Iter b; int a; + for (b=inter.begin(),a=1 ;b != inter.end();b++,a++) + { tab_Elem(a) = (int) (b->donnees[0]); // transformation en entier + tab_FA(a) = (int) (b->donnees[1]); // transformation en entier + } + return true; + } + } + return false; + }; + +// affichage et definition interactive des commandes +// nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples +// cas : =1 premier passage, il s'agit de références de noeuds uniquement +// cas : =2 second passage, il s'agit de l'ensemble des possibilités de références +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) + { ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier + if (cas == 1) + { if (ParaGlob::Francais()) {cout << "\n erreur: cas = "; } + else { cout << "\n error: case = "; }; + cout << cas << "\n ReferenceAF::Info_commande_Ref(...."; + Sortie(1); + } + else + { if (indic ==3) // cas d'une ref de surface d'élément + { if (ParaGlob::Francais()) + {sort << "\n # -- exemple de reference de face d'element";} + else {sort << "\n # -- exemple of a reference of an element face ";}; + cout << "\n F_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 <<" "; + } + sort << "\n \n"; + } + else if (indic ==4) // cas d'une ref d'arete d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference d'arete d'elements ";} + else {sort << "\n # -- exemple of a reference of an element edge ";}; + cout << "\n A_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + } + sort << "\n \n"; + } + else if (indic ==5) // cas d'une ref de noeuds d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de noeuds d'elements ";} + else {sort << "\n # -- exemple of a reference of an element node ";}; + cout << "\n P_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + } + sort << "\n \n"; + } + else if (indic ==6) // cas d'une ref de pt d'integ d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration d'elements ";} + else {sort << "\n # -- exemple of a reference of an element gauss point ";}; + cout << "\n G_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + } + sort << "\n \n"; + } + + else if (indic ==7) // cas d'une ref de pt d'integ de face d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration de face d'elements " + << "\n nb_elem nb_face nb_pti " ;} + else {sort << "\n # -- exemple of a reference of Gauss point for an element facet " + << "\n nb_elem nb_facet nb_Gauss ";}; + cout << "\n P_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 << setw (6)<< 1 <<" "; + }; + sort << "\n \n"; + } + else if (indic ==8) // cas d'une ref de pt d'integ d'arête d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration d'arete d'elements " + << "\n nb_elem nb_arete nb_pti " ;} + else {sort << "\n # -- exemple of a reference of Gauss point for an element edge " + << "\n nb_elem nb_edge nb_Gauss ";}; + cout << "\n L_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 << setw (6)<< 1<<" "; + }; + sort << "\n \n"; + } + } + }; + +//----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Lecture_base_info(ifstream& ent,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Lect_int_base_info(ent); + // lecture des deux tableaux d'entiers qui ont la même taille + int tab_FATaille; string toto; + ent >> toto >> tab_FATaille; + tab_Elem.Change_taille(tab_FATaille); + tab_FA.Change_taille(tab_FATaille); + for (int i=1;i<= tab_FATaille; i++) + ent >> tab_Elem(i) >> tab_FA(i) ; + }; + }; + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceAF::Ecriture_base_info(ofstream& sort,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Ecrit_int_base_info(sort); + // écriture des deux tableau d'entier, normalement ils ont la même taille + int tab_FATaille = tab_FA.Taille(); + #ifdef MISE_AU_POINT + if ( tab_FATaille != tab_Elem.Taille()) + { if (ParaGlob::Francais()) + {cout << " \n erreur, les deux tableaux ont une taille differente : ";} + else {cout << " \n error, the two tabs have not the same size : ";}; + cout << tab_FATaille << " " << tab_Elem.Taille(); + Sortie(1); + } + #endif + sort << "tailleAF " << tab_FATaille << " "; + for (int i=1;i<= tab_FATaille; i++) + sort << tab_Elem(i) << " " << tab_FA(i) << " "; + sort << "\n"; + }; + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Affiche les donnees des références dans le flux passé en paramètre +void ReferenceAF::Affiche_dans_lis(ofstream& sort) const + { int taille_tab= tab_Elem.Taille(); + // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas + if (taille_tab > 0 ) + { sort << "\n" << setw (6) << nom_ref << " "; + int nb_par_ligne=20; + for (int i=1,nb_p_l=1;i<=taille_tab;i++,nb_p_l++) + { if(nb_p_l > nb_par_ligne) + { nb_p_l=1; sort << "\n";} + sort << tab_Elem(i) << " " << tab_FA(i) << " "; + }; + sort << "\n"; + } + #ifdef MISE_AU_POINT + else if (ParaGlob::NiveauImpression() > 1) + { cout << "\n attention: ref "< surface relatives à des éléments, + // =4 -> arête relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + + // Constructeur fonction du nb de maillage et du type de ref + ReferenceAF (int nbmaille , int indic); + + // Constructeur fonction de deux tableaux de numeros, le premier pour les numéros + // d'éléments le second pour les numéros de faces, ou d'aretes, ou de noeud d'element, + // ou de pt d'integ, du nb de maillage, du type de ref + ReferenceAF (const Tableau& tabelem,const Tableau& tab + ,int nbmaille , int indic, string nom = "rien_actuellement"); + // idem mais avec des listes d'entiers plutôt que des tableaux + ReferenceAF (const list & list_elem,const list & list_num + ,int nbmaille , int indic, string nom = "rien_actuellement"); + + // Constructeur fonction d'un nom de reference + // du nb de maillage, du type de ref + ReferenceAF (string nom,int nbmaille , int indic); + + // Constructeur de copie + ReferenceAF (const ReferenceAF& ref); + + + // DESTRUCTEUR : + + ~ReferenceAF (); + + + // METHODES : + + // création d'une référence du même type contenant les mêmes info + // que la référence donnée en argument: utilisation du constructeur de copie + Reference* Nevez_Ref_copie() const + {ReferenceAF* ref_ret=new ReferenceAF(*this); return ref_ret;} ; + + Reference& operator= (const Reference& ref); + + // Retourne le tableau des numeros d'élément + const Tableau& Tab_Elem() const + { return tab_Elem; }; + + // Retourne le tableau des numeros de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + const Tableau& Tab_FA() const + { return tab_FA; }; + + // Retourne le ieme element du tableau d'éléments + // de la reference (acces lecture uniquement) + int NumeroElem(int i) const + { return tab_Elem(i); }; + + // Retourne le ieme element du tableau de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + // de la reference (acces lecture uniquement) + int NumeroFA(int i) const + { return tab_FA(i); }; + + + // Retourne le nombre de numeros de la reference + int Taille () const + { return tab_Elem.Taille(); }; + + // change un numéro i de référence + // nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, ou de noeud d'element, + // ou de points d'integ + void Change_num_AF_dans_ref(int i,int nbe, int nbAF); + + // change les 2 tableaux de la ref + void Change_tab_num(const Tableau& tabele,const Tableau& tab); + + // indique si le numéro d'élément et le numéro de faces, ou d'arêtes, ou de noeud d'element, ou de points + // d'integ, passé en argument, fait partie de la référence + // nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, ou de noeud d'element, + // ou de points d'integ + bool Contient_AF(int nbe, int nbAF) const; + + // supprime les doublons internes éventuels dans la référence + virtual void Supprime_doublons_internes(); + + // Affiche les donnees liees a la reference + void Affiche () const; + +//-------- méthodes découlant de virtuelles ---------------- + + // Affiche les donnees des références dans le flux passé en paramètre + void Affiche_dans_lis(ofstream& sort) const ; + + // lecture d'une liste de reference + bool LectureReference(UtilLecture & entreePrinc); + + // affichage et definition interactive des commandes + // nbMaxi: nombre maxi d'éléments pour les exemples + // cas : =1 premier passage, il s'agit de références de noeuds uniquement, + // donc ici cela génére une erreur + // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références + void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas); + + //----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + void Lecture_base_info(ifstream& ent,const int cas); + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + void Ecriture_base_info(ofstream& sort,const int cas); + + protected : + + Tableau tab_Elem; // tableau des numeros des éléments de la reference + Tableau tab_FA; // tableau des numeros des faces ou arêtes de la reference + // ou noeud d'element, ou de points d'intégrations d'élément + +}; + +#ifndef MISE_AU_POINT + #include "ReferenceAF.cc" + #define REFERENCEAF_H_deja_inclus +#endif + +#endif + + diff --git a/References/ReferenceFA.h b/References/ReferenceFA.h new file mode 100644 index 0000000..92c18cd --- /dev/null +++ b/References/ReferenceFA.h @@ -0,0 +1 @@ +// FICHIER : ReferenceNE.h // CLASSE : ReferenceNE /************************************************************************ * UNIVERSITE DE BRETAGNE SUD (UBS) --- I.U.P/I.U.T. DE LORIENT * ************************************************************************ * LABORATOIRE DE GENIE MECANIQUE ET MATERIAUX (LG2M) * * Centre de Recherche Rue de Saint Maudé - 56325 Lorient cedex * * tel. 02.97.87.45.70 fax. 02.97.87.45.72 http://www-lg2m.univ-ubs.fr * ************************************************************************ * DATE: 23/01/97 * * $ * * AUTEUR: G RIO (mailto:gerard.rio@univ-ubs.fr) * * Tel 0297874571 fax : 02.97.87.45.72 * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT: Def, stockage et manipulation des références pour les * * noeuds et les éléments. * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * $ * ************************************************************************/ #ifndef REFERENCENE_H #define REFERENCENE_H class ReferenceNE : public Reference { public : // CONSTRUCTEURS : // Constructeur par defaut ReferenceNE ( string nom = "rien_actuellement"); // Constructeur fonction d'un tableau des numeros de la reference // du nb de maillage, du type de ref ReferenceNE (const Tableau& tab,int nbmaille , int indic, string nom = "rien_actuellement"); // Constructeur fonction d'un nom de reference // du nb de maillage, du type de ref ReferenceNE (string nom,int nbmaille , int indic); // Constructeur de copie ReferenceNE (const ReferenceNE& ref); // DESTRUCTEUR : ~ReferenceNE (); // METHODES : inline Reference& operator= (const Reference& ref) // Surcharge de l'operateur = : realise l'egalite entre deux references { indic = ref.indic; nbmaille = ref.nbmaille; nom_ref = ref.nom_ref; tab_num = ref.tab_num; return (*this); }; inline Tableau& Tab_num () // Retourne le tableau des numeros de la reference { return tab_num; }; inline string Nom () const // Retourne le nom associe a la reference { return nom_ref; }; inline int Indic () const // Retourne le type de reference { return indic; }; inline int Nbmaille() const // Retourne le numero du maillage auquelle la reference se rattache { return nbmaille; }; inline int& Numero(int i) // Retourne le ieme element du tableau des numeros // de la reference (acces lecture et ecriture) { return tab_num(i); }; inline int Numero(int i) const // Retourne le ieme element du tableau des numeros // de la reference (acces lecture uniquement) { return tab_num(i); }; inline int Taille () const // Retourne le nombre de numeros de la reference { return tab_num.Taille(); }; inline void Change_nom (string nouveau_nom) // Remplace l'ancien nom de la reference par nouveau_nom { nom_ref = nouveau_nom; }; inline void Affiche () const // Affiche les donnees liees a la reference { cout << "\nNom de la reference : " << nom_ref << " , maillage nb =" << nbmaille << ", de type = " << indic << '\n'; cout << "Taille du tableau : " << tab_num.Taille() << " .\n"; cout << "Composante(s) :\n\t[ "; for (int i=1;i<=tab_num.Taille();i++) cout << tab_num(i) << " "; cout << "]\n\n"; }; protected : string nom_ref; // nom de la reference int nbmaille; // numero du maillage auquelle la reference se rapporte int indic; // indic = 1 : il s'agit de reference de noeud // indic = 2 : il s'agit de reference d'element // =3 -> surface, =4 -> arrete Tableau tab_num; // tableau des numeros de la reference }; #endif \ No newline at end of file diff --git a/References/ReferenceNE.cc b/References/ReferenceNE.cc new file mode 100644 index 0000000..49771c4 --- /dev/null +++ b/References/ReferenceNE.cc @@ -0,0 +1,386 @@ +// FICHIER : ReferenceNE.cp +// CLASSE : ReferenceNE + + +#include "ReferenceNE.h" +#include "PtTabRel.h" + +#ifndef REFERENCENE_H_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur par defaut (appel au constructeur par defaut de Tableau) +ReferenceNE::ReferenceNE (string nom): + Reference(nom),tab_num() + { }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction du nb de maillage et du type de ref +ReferenceNE::ReferenceNE (int nb , int ind) : + Reference(nb,ind),tab_num() + { }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur utile si le tableau des numeros +// de la reference est connu, le nb de maillage, le type de ref +ReferenceNE::ReferenceNE (const Tableau& tab,int nb, int ind, string nom): + Reference(nom,nb,ind),tab_num(tab) + { }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur utile si une liste des numeros +// de la reference est connu, le nb de maillage, le type de ref +ReferenceNE::ReferenceNE (const list & list_entiers,int nb, int ind, string nom): + Reference(nom,nb,ind),tab_num(list_entiers.size()) + { int tail = tab_num.Taille(); + list ::const_iterator it=list_entiers.begin(); + for (int i=1;i<= tail;i++,it++) + tab_num(i)=(*it); + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur utile si le nom de la reference est connu +ReferenceNE::ReferenceNE (string nom,int nb , int ind) : + Reference(nom,nb,ind),tab_num() + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur de copie +ReferenceNE::ReferenceNE (const ReferenceNE& ref): + Reference (ref),tab_num(ref.tab_num) + { }; + +// Destructeur +#ifndef MISE_AU_POINT + inline +#endif +ReferenceNE::~ReferenceNE () + { }; + +//================== METHODES : ================================ + +#ifndef MISE_AU_POINT + inline +#endif +Reference& ReferenceNE::operator= (const Reference& ref) + { *this = this->Reference::operator=(ref); // pour la partie de la classe mère + #ifdef MISE_AU_POINT + // vérification du type de ref + if ((ref.Indic() != 2) && (ref.Indic() != 1)) + {if (ParaGlob::Francais()) + {cout << " \n erreur dans l'affectation de reference : ReferenceNE::operator= (const Reference& ref)" + << "\n la reference ref n'est ni celle de noeud ni celle d'elements "; + } + else + {cout << " \n error in the operator of reference : ReferenceNE::operator= (const Reference& ref)" + << "\n the reference ref is not a reference of a node or of an element " + << " or a gauss point "; + }; + }; + #endif + tab_num = ((ReferenceNE&) ref).tab_num; + return (*this); + }; + + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceNE::Affiche () const + { // affichage du type de référence + if (indic == 1) + { if (ParaGlob::Francais()) {cout << "\n reference de noeud ";} + else {cout << "\n reference of node ";};} + else if (indic == 2) + { if (ParaGlob::Francais()) {cout << "\n reference d'element ";} + else {cout << "\n reference of element ";};} + else + { if (ParaGlob::Francais()) {cout << "\n reference de type non défini ";} + else {cout << "\n reference not defined ";};} + // affichage pour la partie de la classe mère + this->Reference::Affiche(); + // partie spécifique + if (ParaGlob::Francais()) {cout << "Taille du tableaux : " ;} + else {cout << "size of the tab : " ;}; + cout << tab_num.Taille() << " .\n"; + if (ParaGlob::Francais()) {cout << "Composante(s)";} + else {cout << "Component(s)";}; + cout << " :\n\t[ "; + for (int i=1;i<=tab_num.Taille();i++) + cout << tab_num(i) << " "; + cout << "]\n\n"; + }; + +// lecture d'une liste de references de noeuds ou d'éléments +#ifndef MISE_AU_POINT + inline +#endif +bool ReferenceNE::LectureReference(UtilLecture & entreePrinc) + { *(entreePrinc.entree) >> nom_ref; // lecture d'une reference + // si l'on est à la fin de la ligne on passe à la ligne suivante + //cout << "\n rdstate " << entreePrinc.entree->rdstate() << endl; + if ((entreePrinc.entree->eof() != 0) && (!(entreePrinc.entree->fail()))) + { entreePrinc.NouvelleDonnee(); } + // on utilise une liste pour la lecture, ce qui permet de lire une nombre quelconque + // de numéros attachés à une référence + list inter; // on utilise des réels car c'est déjà défini par ailleurs + // mais cela n'a aucune importance sur le traitement + int il; + + if ((entreePrinc.entree->rdstate() != 0) + && (!motCle.SimotCle(entreePrinc.tablcar))) + // si le buffer ne contiend pas de mot cle et qu'il y a un + // pb de lecture ( donc pas de def de reference) + + { if (ParaGlob::Francais()) + {cout << " \n Erreur de lecture de reference \n contenu du buffer = ";} + else {cout << " \n Error of reference reading \n buffer = ";}; + cout << entreePrinc.tablcar << endl; + if (ParaGlob::Francais()) + { entreePrinc.MessageBuffer("lecture d une reference de noeud ou d'element");} + else + {entreePrinc.MessageBuffer + ("reading of a reference of node or element "); }; + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie (1); + } + else if (motCle.SimotCle(entreePrinc.tablcar)) + { // fin de la lecture de reference + // remise correcte du flot + entreePrinc.FlotDebutDonnee(); + return false; + } + else + { + // cas ou on a bien lu un nom de reference + { + il = 0; // nb de nb d'entier lu + bool fin = false; + // les deux cas qui font sortir de la boucle sont l'apparition + // d'un mot cle ou une erreur en lecture dans entier + // apres une bonne lecture sur la meme ligne + bool aumoinsune = true; + bool prem = true; // ne sert que pour le cas d'une reference sans numero + while ( (!fin) & aumoinsune) + {aumoinsune = false; + // def du maillon à lire dans la liste + Reels1 as1; + // while (!entreePrinc.entree->rdstate()) // lecture tant qu'il n'y a pas d'erreur + while ((entreePrinc.entree->rdstate()== 0)&& // lecture tant qu'il n'y a pas d'erreur + (!(entreePrinc.entree->eof()))) + { *(entreePrinc.entree) >> as1.donnees; // lecture d'un entier mis dans un réel + // pour la verif + // pour mémoire ici on a + /* enum io_state + { badbit = 1<<0, // -> 1 dans rdstate() + eofbit = 1<<1, // -> 2 + failbit = 1<<2, // -> 4 + goodbit = 0 // -> O + };*/ + // if ((entreePrinc.entree->rdstate() == 0)|| + /// (entreePrinc.entree->rdstate() == 2)) + // (entreePrinc.entree->eof())) + // cout << "\n entreePrinc.entree->eof()" << entreePrinc.entree->eof(); + // cout << "\n entreePrinc.entree->bad()" << entreePrinc.entree->bad(); + // cout << "\n entreePrinc.entree->fail()" << entreePrinc.entree->fail() << endl; + #ifdef ENLINUX + if (entreePrinc.entree->rdstate() == 0) + #else + /* #ifdef SYSTEM_MAC_OS_X_unix + if (entreePrinc.entree->rdstate() == 0) + #else*/ + if (((entreePrinc.entree->rdstate() == 0)|| + (entreePrinc.entree->eof()))&&(!(entreePrinc.entree->bad())) + &&(!(entreePrinc.entree->fail()))) + // #endif + #endif + {il++; + aumoinsune = true; + prem = false; + inter.push_back(as1); + } + } + + if ((aumoinsune) || prem ) + {entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + if (motCle.SimotCle(entreePrinc.tablcar)) + // c'est un mot cle + fin = true; + } + else + // remise correcte du flot pour la lecture + //d'une prochaine reference + entreePrinc.FlotDebutDonnee(); + } + if (il == 0 ) + { if (ParaGlob::Francais()) {cout << "\n WARNING : aucun numero attache a la reference = ";} + else {cout << "\n WARNING : no number linked to the reference = ";}; + cout << nom_ref << endl; + } + // transfert dans le tableau tab + tab_num.Change_taille(il); + listdouble1Iter b; int a; + for (b=inter.begin(),a=1 ;b != inter.end();b++,a++) + tab_num(a) = (int) (b->donnees); // transformation en entier + return true; + } + } + return false; + }; + +// supprime les doublons internes éventuels dans la référence +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceNE::Supprime_doublons_internes() +{ //Tableau tab_num; + int taille = tab_num.Taille(); + list agarder; // contiendra les seules numéros à sauvegarder + for (int i=1;i<=taille;i++) + { bool bon=true; + for (int j=i+1;j<=taille;j++) + if (tab_num(i)==tab_num(j)) + {bon=false; + if (ParaGlob::NiveauImpression() > 3) + { cout << "\n *** attention suppression doublon: ref "<::iterator ili,ilifin = agarder.end(); + int position=1; + for (ili=agarder.begin();ili!=ilifin;ili++,position++) + {tab_num(position) = tab_num(*ili); //position est toujours < *ili donc on écrase a partir du bas + // et tab_num(*ili) est toujours valide + }; + // on supprime les données de new_taille à taille + tab_num.Change_taille(new_taille); + }; +}; + +// affichage et definition interactive des commandes +// nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples +// cas : =1 premier passage, il s'agit de références de noeuds uniquement +// cas : =2 second passage, il s'agit de l'ensemble des possibilités de références +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceNE::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) + { ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier + if (cas == 1) + { if (ParaGlob::Francais()) + {sort << "\n # -- exemple de reference de noeud ";} + else {sort << "\n # -- exemple of a reference of node ";}; + sort << "\n N_tout " ; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 <<" "; + } + sort << "\n \n"; + } + else + { if (indic ==1) // cas d'une ref de noeud + { if (ParaGlob::Francais()) + {sort << "\n # -- exemple de reference de noeud ";} + else {sort << "\n # -- exemple of a reference of node ";}; + cout << "\n N_deb 1 "; + } + else // cas d'une ref d'élément + { if (ParaGlob::Francais()) + {sort << "\n # -- exemple de reference d'elements ";} + else {sort << "\n # -- exemple of a reference of elements ";}; + cout << "\n E_tout_les_elements "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 <<" "; + } + sort << "\n \n"; + } + } + }; + +//----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceNE::Lecture_base_info(ifstream& ent,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Lect_int_base_info(ent); + // lecture du tableau d'entier + ent >> tab_num ; + }; + }; + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferenceNE::Ecriture_base_info(ofstream& sort,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Ecrit_int_base_info(sort); + // écriture du tableau d'entier + sort << tab_num; + }; + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Affiche les donnees des références dans le flux passé en paramètre +void ReferenceNE::Affiche_dans_lis(ofstream& sort) const + { int taille_tab= tab_num.Taille(); + // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas + if (taille_tab > 0 ) + { sort << "\n" << setw (6) << nom_ref << " "; + int nb_par_ligne=20; + for (int i=1,nb_p_l=1;i<=taille_tab;i++,nb_p_l++) + { if(nb_p_l > nb_par_ligne) + { nb_p_l=1; sort << "\n";} + sort << tab_num(i) << " "; + } + sort << "\n"; + } +// #ifdef MISE_AU_POINT + else if (ParaGlob::NiveauImpression() > 1) + { sort < surface relatives à des éléments, + // =4 -> arete relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + + // Constructeur fonction du nb de maillage et du type de ref + ReferenceNE(int nbmaille , int indic); + + // Constructeur fonction d'un tableau des numeros de la reference + // du nb de maillage, du type de ref + ReferenceNE(const Tableau& tab,int nbmaille , int indic, string nom = "rien_actuellement"); + // idem mais avec une liste d'entiers plutôt qu'un tableau + ReferenceNE(const list & list_entiers,int nbmaille , int indic, string nom = "rien_actuellement"); + + // Constructeur fonction d'un nom de reference + // du nb de maillage, du type de ref + ReferenceNE(string nom,int nbmaille , int indic); + + // Constructeur de copie + ReferenceNE(const ReferenceNE& ref); + + + // DESTRUCTEUR : + + ~ReferenceNE (); + + // METHODES : + + // création d'une référence du même type contenant les mêmes info + // que la référence donnée en argument: utilisation du constructeur de copie + Reference* Nevez_Ref_copie() const + {ReferenceNE* ref_ret=new ReferenceNE(*this); return ref_ret;} ; + + Reference& operator= (const Reference& ref); + + // Retourne le tableau des numeros de la reference en lecture uniquement + const Tableau& Tab_num() const + { return tab_num; }; + +/* inline int& Numero(int i) + // Retourne le ieme element du tableau des numeros + // de la reference (acces lecture et ecriture) + { return tab_num(i); };*/ + + // Retourne le ieme element du tableau des numeros + // de la reference (acces lecture uniquement) + int Numero(int i) const + { return tab_num(i); }; + + // Retourne le nombre de numeros de la reference + int Taille() const + { return tab_num.Taille(); }; + // change un numéro de référence + void Change_num_dans_ref(int i,int nv_num) + { tab_num(i)=nv_num;}; + + // change le tableau de numéro de référence + void Change_tab_num(const Tableau& tab) + {tab_num = tab;}; + + // supprime les doublons internes éventuels dans la référence + virtual void Supprime_doublons_internes(); + + // Affiche les donnees liees a la reference + void Affiche() const; + +//-------- méthodes découlant de virtuelles ---------------- + + // Affiche les donnees des références dans le flux passé en paramètre + void Affiche_dans_lis(ofstream& sort) const ; + + // lecture d'une liste de reference de noeuds ou d'éléments + bool LectureReference(UtilLecture & entreePrinc); + + // affichage et definition interactive des commandes + // nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples + // cas : =1 premier passage, il s'agit de références de noeuds uniquement + // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références + void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas); + + //----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + void Lecture_base_info(ifstream& ent,const int cas); + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + void Ecriture_base_info(ofstream& sort,const int cas); + + protected : + + Tableau tab_num; // tableau des numeros de noeuds ou d'élément de la reference + +}; + +#ifndef MISE_AU_POINT + #include "ReferenceNE.cc" + #define REFERENCENE_H_deja_inclus +#endif + +#endif + + diff --git a/References/ReferencePtiAF.cc b/References/ReferencePtiAF.cc new file mode 100755 index 0000000..e15610c --- /dev/null +++ b/References/ReferencePtiAF.cc @@ -0,0 +1,593 @@ +// FICHIER : ReferencePtiAF.cc +// CLASSE : ReferencePtiAF + + +#include "ReferencePtiAF.h" +#include "PtTabRel.h" + +#ifndef REFERENCEPTIAF_H_deja_inclus + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur par defaut (appel au constructeur par defaut de Tableau) +ReferencePtiAF::ReferencePtiAF (string nom): + Reference(nom),tab_Elem(),tab_FA(),tab_pti() + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction du nb de maillage et du type de ref +ReferencePtiAF::ReferencePtiAF (int nb , int ind) : + Reference(nb,ind),tab_Elem(),tab_FA(),tab_pti() + { }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction de trois tableaux de numeros, le premier pour les numéros +// d'éléments le deuxième pour les numéros de faces, ou d'aretes, +// le troisième pour le nb du pt d'integ, +// puis le nb de maillage, et enfin le type de ref +ReferencePtiAF::ReferencePtiAF (const Tableau& tabelem + ,const Tableau& tabAF,const Tableau& tabPti + ,int nbmaille , int indic, string nom): + Reference(nom,nbmaille,indic),tab_Elem(tabelem),tab_FA(tabAF),tab_pti(tabPti) + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur fonction de deux listes de numeros, la première pour les numéros +// d'éléments la seconde pour les numéros de faces, d'aretes, de noeud d'element, ou de point d'integ +// du nb de maillage, du type de ref +ReferencePtiAF::ReferencePtiAF (const list & list_elem,const list & list_numAF + ,const list & list_num_pti + ,int nbmaille , int indic, string nom): + Reference(nom,nbmaille,indic),tab_Elem(list_elem.size()),tab_FA(list_numAF.size()) + ,tab_pti(list_num_pti.size()) + { int tail = tab_Elem.Taille(); + list ::const_iterator it=list_elem.begin(); + for (int i=1;i<= tail;i++,it++) + tab_Elem(i)=(*it); + tail = tab_FA.Taille(); it = list_numAF.begin(); + for (int i=1;i<= tail;i++,it++) + tab_FA(i)=(*it); + + tail = tab_pti.Taille(); it = list_num_pti.begin(); + for (int i=1;i<= tail;i++,it++) + tab_pti(i)=(*it); + + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur utile si le nom de la reference est connu +ReferencePtiAF::ReferencePtiAF (string nom,int nb , int ind) : + Reference(nom,nb,ind),tab_Elem(),tab_FA(),tab_pti() + { }; + + +#ifndef MISE_AU_POINT + inline +#endif +// Constructeur de copie +ReferencePtiAF::ReferencePtiAF (const ReferencePtiAF& ref): + Reference (ref),tab_Elem(ref.tab_Elem),tab_FA(ref.tab_FA) + ,tab_pti(ref.tab_pti) + { }; + +// Destructeur +#ifndef MISE_AU_POINT + inline +#endif +ReferencePtiAF::~ReferencePtiAF () + { }; + +//================== METHODES : ================================ + +#ifndef MISE_AU_POINT + inline +#endif +Reference& ReferencePtiAF::operator= (const Reference& ref) + { *this = this->Reference::operator=(ref); // pour la partie de la classe mère + #ifdef MISE_AU_POINT + // vérification du type de ref + if ((ref.Indic() != 3) && (ref.Indic() != 4)&& (ref.Indic() != 5)&& (ref.Indic() != 6)) + {if (ParaGlob::Francais()) + {cout << " \n erreur dans l'affectation de reference : ReferencePtiAF::operator= (const Reference& ref)" + << "\n la reference ref n'est ni celle de face, d'arete, de noeud d'element " + << " ou de pt d'integ "; + } + else + {cout << " \n error in the operator of reference : ReferencePtiAF::operator= (const Reference& ref)" + << "\n the reference ref is not a reference of a face, an edge, a node " + << " or a gauss point "; + }; + }; + #endif + tab_Elem = ((ReferencePtiAF&) ref).tab_Elem; + tab_FA = ((ReferencePtiAF&) ref).tab_FA; + tab_pti = ((ReferencePtiAF&) ref).tab_pti; + return (*this); + }; + + + +// change un numéro i de référence +// nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, nbPti +// le num de points d'integ +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Change_num_PtiAF_dans_ref(int i,int nbe, int nbAF, int nbPti) + { if ((i < 1)|| (i>tab_Elem.Taille())) + { cout << "\n *** erreur de changement de numero dans la reference : " << this->Nom() + << "\n le numero demande est le " << i << " ce qui est en dehors des valeurs possibles " + << " qui doivent etre comprises entre 1 et "<Affiche(); + Sortie(1); + }; + tab_Elem(i)=nbe;tab_FA(i)= nbAF;tab_pti(i)= nbPti; + }; + +// change les 3 tableaux de la ref +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Change_tab_num(const Tableau& tabele + ,const Tableau& tabAF,const Tableau& tabPti) + { // on vérifie que les 3 tableaux ont la même taille + if ((tabele.Taille() != tabAF.Taille()) && (tabele.Taille() != tabPti.Taille())) + { cout << "\n *** erreur de changement des trois tableaux dans la reference : " << this->Nom() + << "\n les tailles des trois tableaux sont differentes: taille des elements="<< tabele.Taille() + << ", taille du deuxieme tableau =" << tabAF.Taille() + << ", taille du troisieme tableau ="<< tabPti.Taille() + << " on affiche la ref actuelle : "; + this->Affiche(); + Sortie(1); + }; + tab_Elem=tabele; + tab_FA= tabAF; + tab_pti= tabPti; + }; + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +// indique si le numéro d'élément, le numéro de faces ou d'arêtes, et le num de points +// d'integ, passé en argument, fait partie de la référence +// nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, +// nbPti le num de points d'integ +bool ReferencePtiAF::Contient_PtiAF(int nbe, int nbAF, int nbPti) const + { int tail_tab=tab_Elem.Taille(); + for (int i=1;i<= tail_tab;i++) + if ((tab_Elem(i)==nbe) && (tab_FA(i)==nbAF) && (tab_pti(i)==nbPti)) return true; + return false; + }; + +// Affiche les donnees liees a la reference +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Affiche () const + { // affichage du type de référence + if (indic == 3) + { if (ParaGlob::Francais()) {cout << "\n reference de face d'element";} + else {cout << "\n reference of an element face ";};} + else if (indic == 4) + { if (ParaGlob::Francais()) {cout << "\n reference d'arete d'element";} + else {cout << "\n reference of an element edge ";};} + else if (indic == 5) + { if (ParaGlob::Francais()) {cout << "\n reference de noeud d'element";} + else {cout << "\n reference of node ";};} + else if (indic == 6) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ d'element";} + else {cout << "\n reference of a gauss point ";};} + else if (indic == 7) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ relatif a une face d'element";} + else {cout << "\n reference of a gauss point for a facet of an element ";};} + else if (indic == 8) + { if (ParaGlob::Francais()) {cout << "\n reference de pt d'integ relatif a une arete d'element";} + else {cout << "\n reference of a gauss point for an edge of an element";};} + else + { if (ParaGlob::Francais()) {cout << "\n reference de type non defini ";} + else {cout << "\n reference not defined ";};} + // affichage pour la partie de la classe mère + this->Reference::Affiche(); + // partie spécifique + if (ParaGlob::Francais()) {cout << "Taille des tableaux : " ;} + else {cout << "size of the tab : " ;}; + cout << tab_Elem.Taille() << " .\n"; + if (ParaGlob::Francais()) + {cout << "Composante(s) (1 element puis une face ou arete puis un pt integ ):\n\t[ ";} + else + {cout << "Components(s) (1 element then one face or edge then a gauss point ):\n\t[ ";}; + for (int i=1;i<=tab_Elem.Taille();i++) + cout << tab_Elem(i) << " "<< tab_FA(i) << " "<< tab_pti(i) << " "; + cout << "]\n\n"; + }; + +// supprime les doublons internes éventuels dans la référence +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Supprime_doublons_internes() +{ //Tableau tab_Elem; // tableau des numeros des éléments de la reference + //Tableau tab_FA; // tableau des numeros des faces ou arêtes de la reference + //Tableau tab_pti; // tableau des points d'intégrations + int taille = tab_Elem.Taille(); + list agarder; // contiendra les seules numéros à sauvegarder + for (int i=1;i<=taille;i++) + { bool bon=true; + for (int j=i+1;j<=taille;j++) + if ((tab_Elem(i)==tab_Elem(j))&& (tab_FA(i)==tab_FA(j))&& (tab_pti(i)==tab_pti(j))) + {bon=false; + if (ParaGlob::NiveauImpression() > 3) + { cout << "\n *** attention suppression doublon: ref "<::iterator ili,ilifin = agarder.end(); + int position=1; + for (ili=agarder.begin();ili!=ilifin;ili++,position++) + {tab_Elem(position) = tab_Elem(*ili); //position est toujours < *ili donc on écrase a partir du bas + tab_FA(position) = tab_FA(*ili); // et tab_Elem(*ili) et tab_FA(*ili) sont toujours valides + tab_pti(position) = tab_pti(*ili); // et tab_pti(*ili) + }; + // on supprime les données de new_taille à taille + tab_Elem.Change_taille(new_taille); + tab_FA.Change_taille(new_taille); + tab_pti.Change_taille(new_taille); + }; +}; + +// lecture d'une liste de references +#ifndef MISE_AU_POINT + inline +#endif +bool ReferencePtiAF::LectureReference(UtilLecture & entreePrinc) + { *(entreePrinc.entree) >> nom_ref; // lecture d'une reference + // si l'on est à la fin de la ligne on passe à la ligne suivante + //cout << "\n rdstate " << entreePrinc.entree->rdstate() << endl; + if ((entreePrinc.entree->eof() != 0) && (!(entreePrinc.entree->fail()))) + { entreePrinc.NouvelleDonnee(); } + // on utilise une liste pour la lecture, ce qui permet de lire une nombre quelconque + // de numéros attachés à une référence + list inter; // on utilise des réels car c'est déjà défini par ailleurs + // mais cela n'a aucune importance sur le traitement + int il; + + if ((entreePrinc.entree->rdstate() != 0) + && (!motCle.SimotCle(entreePrinc.tablcar))) + // si le buffer ne contiend pas de mot cle et qu'il y a un + // pb de lecture ( donc pas de def de reference) + { if (ParaGlob::Francais()) + {cout << " \n Erreur de lecture de reference \n contenu du buffer = ";} + else {cout << " \n Error of reference reading \n buffer = ";}; + cout << entreePrinc.tablcar << endl; + if (ParaGlob::Francais()) + {entreePrinc.MessageBuffer + ("lecture d une reference de pti de face ou d'arete d'element "); } + else + {entreePrinc.MessageBuffer + ("reading of a reference of Gauss point of face or edge of element "); }; + throw (UtilLecture::ErrNouvelleDonnee(-1)); + Sortie (1); + } + else if (motCle.SimotCle(entreePrinc.tablcar)) + { // fin de la lecture de reference + // remise correcte du flot + entreePrinc.FlotDebutDonnee(); + return false; + } + else + { + // cas ou on a bien lu un nom de reference + { + il = 0; // nb de nb d'entier lu + bool fin = false; + // les deux cas qui font sortir de la boucle sont l'apparition + // d'un mot cle ou une erreur en lecture dans entier + // apres une bonne lecture sur la meme ligne + bool aumoinsune = true; + bool prem = true; // ne sert que pour le cas d'une reference sans numero + while ( (!fin) & aumoinsune) + {aumoinsune = false; + // def du maillon à lire dans la liste + Reels3 as1; + // while (!entreePrinc.entree->rdstate()) // lecture tant qu'il n'y a pas d'erreur + while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur + (!(entreePrinc.entree->eof()))) + { // lecture de 3 entiers mis dans deux réels + *(entreePrinc.entree) >> as1.donnees[0] ; + // si jamais on est à la fin d'une ligne on passe à la ligne suivante + if (entreePrinc.entree->eof()) + { + #ifdef ENLINUX + if (!(entreePrinc.entree->bad())) + // on continue que si le flot est correcte car en linux il s'apperçoit du pb + // qu'après la mauvaise lecture, c'est-à-dire eof() ne fonctionne pas correctement + { break; } + #endif + /* #ifdef SYSTEM_MAC_OS_X_unix + if (!(entreePrinc.entree->bad())) + // on continue que si le flot est correcte car en linux il s'apperçoit du pb + // qu'après la mauvaise lecture, c'est-à-dire eof() ne fonctionne pas correctement + { break; } + #endif */ + entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + }; + *(entreePrinc.entree) >> as1.donnees[1]; + if (entreePrinc.entree->eof()) + { + #ifdef ENLINUX + if (!(entreePrinc.entree->bad())) + // on continue que si le flot est correcte car en linux il s'apperçoit du pb + // qu'après la mauvaise lecture, c'est-à-dire eof() ne fonctionne pas correctement + { break; } + #endif + entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + }; + *(entreePrinc.entree) >> as1.donnees[2]; + // pour la verif + // pour mémoire ici on a + /* enum io_state + { badbit = 1<<0, // -> 1 dans rdstate() + eofbit = 1<<1, // -> 2 + failbit = 1<<2, // -> 4 + goodbit = 0 // -> O + };*/ +// if ((entreePrinc.entree->rdstate() == 0)|| +// (entreePrinc.entree->eof() )) + #ifdef ENLINUX + if (entreePrinc.entree->rdstate() == 0) + #else + /* #ifdef SYSTEM_MAC_OS_X_unix + if (entreePrinc.entree->rdstate() == 0) + #else*/ + if (((entreePrinc.entree->rdstate() == 0)|| + (entreePrinc.entree->eof()))&&(!(entreePrinc.entree->bad())) + &&(!(entreePrinc.entree->fail()))) + // #endif + #endif + {il++; + aumoinsune = true; + prem = false; + inter.push_back(as1); + } + } + + if ((aumoinsune) || prem ) + {entreePrinc.NouvelleDonnee(); // lecture d'une nouvelle ligne + if (motCle.SimotCle(entreePrinc.tablcar)) + // c'est un mot cle + fin = true; + } + else + // remise correcte du flot pour la lecture + //d'une prochaine reference + entreePrinc.FlotDebutDonnee(); + } + if (il == 0 ) + { if (ParaGlob::Francais()) {cout << "\n WARNING : aucun numero attache a la reference = ";} + else {cout << "\n WARNING : no number linked to the reference = ";}; + cout << nom_ref << endl; + }; + // transfert dans les tableaux + tab_Elem.Change_taille(il); + tab_FA.Change_taille(il); + tab_pti.Change_taille(il); + listdouble3Iter b; int a; + for (b=inter.begin(),a=1 ;b != inter.end();b++,a++) + { tab_Elem(a) = (int) (b->donnees[0]); // transformation en entier + tab_FA(a) = (int) (b->donnees[1]); // transformation en entier + tab_pti(a) = (int) (b->donnees[2]); // transformation en entier + } + return true; + } + } + return false; + }; + +// affichage et definition interactive des commandes +// nbMaxi: nombre maxi de noeud ou d'éléments pour les exemples +// cas : =1 premier passage, il s'agit de références de noeuds uniquement +// cas : =2 second passage, il s'agit de l'ensemble des possibilités de références +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas) + { ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier + if (cas == 1) + { if (ParaGlob::Francais()) {cout << "\n erreur: cas = "; } + else { cout << "\n error: case = "; }; + cout << cas << "\n ReferencePtiAF::Info_commande_Ref(...."; + Sortie(1); + } + else + { if (indic ==3) // cas d'une ref de surface d'élément + { if (ParaGlob::Francais()) + {sort << "\n # -- exemple de reference de face d'element";} + else {sort << "\n # -- exemple of a reference of an element face ";}; + cout << "\n F_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 <<" "; + }; + sort << "\n \n"; + } + else if (indic ==4) // cas d'une ref d'arete d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference d'arete d'elements ";} + else {sort << "\n # -- exemple of a reference of an element edge ";}; + cout << "\n A_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + }; + sort << "\n \n"; + } + else if (indic ==5) // cas d'une ref de noeuds d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de noeuds d'elements ";} + else {sort << "\n # -- exemple of a reference of an element node ";}; + cout << "\n P_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + }; + sort << "\n \n"; + } + else if (indic ==6) // cas d'une ref de pt d'integ d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration d'elements ";} + else {sort << "\n # -- exemple of a reference of an element gauss point ";}; + cout << "\n G_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1<<" "; + }; + sort << "\n \n"; + } + + else if (indic ==7) // cas d'une ref de pt d'integ de face d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration de face d'elements " + << "\n nb_elem nb_face nb_pti " ;} + else {sort << "\n # -- exemple of a reference of Gauss point for an element facet " + << "\n nb_elem nb_facet nb_Gauss ";}; + cout << "\n P_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 << setw (6)<< 1 <<" "; + }; + sort << "\n \n"; + } + else if (indic ==8) // cas d'une ref de pt d'integ d'arête d'élément + { if (ParaGlob::Francais()) + { sort << "\n # -- exemple de reference de point d'integration d'arete d'elements " + << "\n nb_elem nb_arete nb_pti " ;} + else {sort << "\n # -- exemple of a reference of Gauss point for an element edge " + << "\n nb_elem nb_edge nb_Gauss ";}; + cout << "\n L_tout "; + int compteur_ligne=0; + for (int n1=1;n1<= nbMaxi;n1++,compteur_ligne++) + { if (compteur_ligne > 10) + { compteur_ligne = 0; sort << "\n";} + sort << setw (6) << n1 << setw (6)<< 1 << setw (6)<< 1<<" "; + }; + sort << "\n \n"; + } + + + + } + }; + +//----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Lecture_base_info(ifstream& ent,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Lect_int_base_info(ent); + // lecture des 3 tableaux d'entiers qui ont la même taille + int tab_FATaille; string toto; + ent >> toto >> tab_FATaille; + tab_Elem.Change_taille(tab_FATaille); + tab_FA.Change_taille(tab_FATaille); + tab_pti.Change_taille(tab_FATaille); + for (int i=1;i<= tab_FATaille; i++) + ent >> tab_Elem(i) >> tab_FA(i) >> tab_pti(i); + }; + }; + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) +#ifndef MISE_AU_POINT + inline +#endif +void ReferencePtiAF::Ecriture_base_info(ofstream& sort,const int cas) + { // ici a priori il n'y a pas de de données supposées variables + if (cas == 1) + { + // appelle de la méthode de la classe mère + Ecrit_int_base_info(sort); + // écriture des trois tableau d'entier, normalement ils ont la même taille + int tab_FATaille = tab_FA.Taille(); + #ifdef MISE_AU_POINT + if (( tab_FATaille != tab_Elem.Taille()) || (tab_FATaille != tab_pti.Taille())) + { if (ParaGlob::Francais()) + {cout << " \n erreur, les trois tableaux ont une taille differente : ";} + else {cout << " \n error, the 3 tabs have not the same size : ";}; + cout << "\n taille elem= "<< tab_Elem.Taille() + << " taille F ou A = "<< tab_FATaille + << " taille pti = "<< tab_pti.Taille(); + Sortie(1); + } + #endif + sort << "taillePtiAF " << tab_FATaille << " "; + for (int i=1;i<= tab_FATaille; i++) + sort << tab_Elem(i) << " " << tab_FA(i) << " "<< tab_pti(i) << " "; + sort << "\n"; + }; + }; + +#ifndef MISE_AU_POINT + inline +#endif +// Affiche les donnees des références dans le flux passé en paramètre +void ReferencePtiAF::Affiche_dans_lis(ofstream& sort) const + { int taille_tab= tab_Elem.Taille(); + // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas + if (taille_tab > 0 ) + { sort << "\n" << setw (6) << nom_ref << " "; + int nb_par_ligne=20; + for (int i=1,nb_p_l=1;i<=taille_tab;i++,nb_p_l++) + { if(nb_p_l > nb_par_ligne) + { nb_p_l=1; sort << "\n";} + sort << tab_Elem(i) << " " << tab_FA(i) << " "<< tab_pti(i) << " "; + }; + sort << "\n"; + } + #ifdef MISE_AU_POINT + else if (ParaGlob::NiveauImpression() > 1) + { cout << "\n attention: ref "< surface relatives à des éléments, + // =4 -> arête relatives à des éléments, + // =5 -> des noeuds relatifs à des éléments + // =6 -> de points d'intégrations relatifs à des éléments + // =7 -> de points d'intégrations relatifs à des surfaces d'éléments + // =8 -> de points d'intégrations relatifs à des arrete d'éléments + + // Constructeur fonction du nb de maillage et du type de ref + ReferencePtiAF (int nbmaille , int indic); + + // Constructeur fonction de trois tableaux de numeros, le premier pour les numéros + // d'éléments le deuxième pour les numéros de faces, ou d'aretes, + // le troisième pour le nb du pt d'integ, + // puis le nb de maillage, et enfin le type de ref + ReferencePtiAF (const Tableau& tabelem,const Tableau& tabAF,const Tableau& tabPti + ,int nbmaille , int indic, string nom = "rien_actuellement"); + // idem mais avec des listes d'entiers plutôt que des tableaux + ReferencePtiAF (const list & list_elem,const list & list_numAF + ,const list & list_num_pti + ,int nbmaille , int indic, string nom = "rien_actuellement"); + + // Constructeur fonction d'un nom de reference + // du nb de maillage, du type de ref + ReferencePtiAF(string nom,int nbmaille , int indic); + + // Constructeur de copie + ReferencePtiAF(const ReferencePtiAF& ref); + + + // DESTRUCTEUR : + + ~ReferencePtiAF(); + + + // METHODES : + + // création d'une référence du même type contenant les mêmes info + // que la référence donnée en argument: utilisation du constructeur de copie + Reference* Nevez_Ref_copie() const + {ReferencePtiAF* ref_ret=new ReferencePtiAF(*this); return ref_ret;} ; + + Reference& operator= (const Reference& ref); + + // Retourne le tableau des numeros d'élément + const Tableau& Tab_Elem() const + { return tab_Elem; }; + + // Retourne le tableau des numeros de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + const Tableau& Tab_FA() const + { return tab_FA; }; + + // Retourne le tableau des numeros des points d'integ + const Tableau& Tab_Pti() const + { return tab_pti; }; + + // Retourne le ieme element du tableau d'éléments + // de la reference (acces lecture uniquement) + int NumeroElem(int i) const + { return tab_Elem(i); }; + + // Retourne le ieme element du tableau de faces, ou d'arêtes, ou de noeud d'element, ou de points d'integ + // de la reference (acces lecture uniquement) + int NumeroFA(int i) const + { return tab_FA(i); }; + + // Retourne le ieme element du tableau de points d'integ + // de la reference (acces lecture uniquement) + int NumeroPti(int i) const + { return tab_pti(i); }; + + + // Retourne le nombre de numeros de la reference + int Taille () const + { return tab_Elem.Taille(); }; + + // change un numéro i de référence + // nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, nbPti + // le num de points d'integ + void Change_num_PtiAF_dans_ref(int i,int nbe, int nbAF, int nbPti); + + // change les 3 tableaux de la ref + void Change_tab_num(const Tableau& tabele,const Tableau& tabAF + ,const Tableau& tabPti); + + // indique si le numéro d'élément, le numéro de faces ou d'arêtes, et le num de points + // d'integ, passé en argument, fait partie de la référence + // nbe: le numéro d'élément, nbAF: le numéro de de faces, ou d'arêtes, + // nbPti le num de points d'integ + bool Contient_PtiAF(int nbe, int nbAF, int nbPti) const; + + // supprime les doublons internes éventuels dans la référence + virtual void Supprime_doublons_internes(); + + // Affiche les donnees liees a la reference + void Affiche () const; + +//-------- méthodes découlant de virtuelles ---------------- + + // Affiche les donnees des références dans le flux passé en paramètre + void Affiche_dans_lis(ofstream& sort) const ; + + // lecture d'une liste de reference + bool LectureReference(UtilLecture & entreePrinc); + + // affichage et definition interactive des commandes + // nbMaxi: nombre maxi d'éléments pour les exemples + // cas : =1 premier passage, il s'agit de références de noeuds uniquement, + // donc ici cela génére une erreur + // cas : =2 second passage, il s'agit de l'ensemble des possibilités de références + void Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas); + + //----- lecture écriture dans base info ----- + // cas donne le niveau de la récupération + // = 1 : on récupère tout + // = 2 : on récupère uniquement les données variables (supposées comme telles) + void Lecture_base_info(ifstream& ent,const int cas); + // cas donne le niveau de sauvegarde + // = 1 : on sauvegarde tout + // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) + void Ecriture_base_info(ofstream& sort,const int cas); + + protected : + + Tableau tab_Elem; // tableau des numeros des éléments de la reference + Tableau tab_FA; // tableau des numeros des faces ou arêtes de la reference + Tableau tab_pti; // tableau des points d'intégrations + +}; + +#ifndef MISE_AU_POINT + #include "ReferencePtiAF.cc" + #define REFERENCEPTIAF_H_deja_inclus +#endif + +#endif + + diff --git a/References/Reference_static.cc b/References/Reference_static.cc new file mode 100644 index 0000000..2235e93 --- /dev/null +++ b/References/Reference_static.cc @@ -0,0 +1,10 @@ +// FICHIER : ReferenceNE.cp +// CLASSE : ReferenceNE + + +#include "ReferenceNE.h" +#include "PtTabRel.h" + + +// --------------- variables statiques --------- + MotCle Reference::motCle; // liste des mots clés