geometrie/src/mg_gestionnaire.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_gestionnaire.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"


#include "mg_gestionnaire.h"


#include "sld_fonction.h"
#include "occ_fonction1.h"


#include <fstream>
//#include "affiche.h"
//#include "message.h"


//using namespace std;

MG_GESTIONNAIRE::MG_GESTIONNAIRE():entiteidmax(0),ouvertsld(0)
{
#ifdef BREP_SLD
    fonction=new SLD_FONCTION;
#endif

#ifdef BREP_OCC
    fonction1=new OCC_FONCTION1;
#endif

}

MG_GESTIONNAIRE::~MG_GESTIONNAIRE()
{
    supprimer_tout_fem_solution();
    supprimer_tout_mg_solution();
    supprimer_tout_mg_maillage();
    supprimer_tout_mg_geometrie();
#ifdef BREP_SLD
    delete fonction;
#endif

#ifdef BREP_OCC
    delete fonction1;
#endif
}

void MG_GESTIONNAIRE::recherche_bonid(MG_IDENTIFICATEUR &ident)
{
    if (ident.get_id()==0)
    {
        entiteidmax++;
        ident.change_id(entiteidmax);
    }
    else
    {
        if (ident.get_id()>entiteidmax) entiteidmax=ident.get_id();
    }
}

void MG_GESTIONNAIRE::recherche_bonidvisuel(MG_IDENTIFICATEUR &ident)
{
    if (ident.get_id()==0)
    {
        entitevisuelidmax++;
        ident.change_id(entitevisuelidmax);
    }
    else
    {
        if (ident.get_id()>entitevisuelidmax) entitevisuelidmax=ident.get_id();
    }
}

// ENTITE MG_GEOMETRIE


int MG_GESTIONNAIRE::ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
{
    recherche_bonid(*mggeo);
    MG_IDENTIFICATEUR *id=mggeo;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second) return FAIL;
    std::pair<const unsigned long,MG_GEOMETRIE*> tmp(mggeo->get_id(),mggeo);
    lst_mg_geometrie.insert(tmp);
    mggeo->change_gestionnaire(this);
    return OK;
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrieid(unsigned long num)
{
    LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.find(num);
    if (i==lst_mg_geometrie.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrie(unsigned int num)
{
    if (!(num<lst_mg_geometrie.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_premier_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
{
    it = lst_mg_geometrie.begin();
    if (it == lst_mg_geometrie.end())
        return NULL;
    return it->second ;
}

MG_GEOMETRIE* MG_GESTIONNAIRE::get_suivant_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
{
    it++;
    if (it==lst_mg_geometrie.end())
        return NULL;
    return it->second;
}

unsigned int MG_GESTIONNAIRE::get_nb_mg_geometrie(void)
{
    return lst_mg_geometrie.size();
}


int MG_GESTIONNAIRE::supprimer_mg_geometrieid(unsigned long num)
{
    MG_GEOMETRIE* mggeo=get_mg_geometrieid(num);
    if (mggeo==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeo;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(num);
    lst_mg_geometrie.erase(j);
    delete mggeo;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_geometrie(unsigned int num)
{
    MG_GEOMETRIE* mggeo=get_mg_geometrie(num);
    if (mggeo==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeo;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(id->get_id());
    lst_mg_geometrie.erase(j);
    delete mggeo;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_geometrie(void)
{
    while (get_nb_mg_geometrie()!=0)
    {
        LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.begin();
        MG_GEOMETRIE* mggeo=(*j).second;
        MG_IDENTIFICATEUR* id=mggeo;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_geometrie.erase(j);
        delete mggeo;
    }
}

// ENTITE MG_MAILLAGE


int MG_GESTIONNAIRE::ajouter_mg_maillage(MG_MAILLAGE *mgmai)
{
    recherche_bonid(*mgmai);
    MG_IDENTIFICATEUR *id=mgmai;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_MAILLAGE*> tmp(mgmai->get_id(),mgmai);
    lst_mg_maillage.insert(tmp);
    mgmai->change_gestionnaire(this);
    return OK;
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillageid(unsigned long num)
{
    LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.find(num);
    if (i==lst_mg_maillage.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillage(unsigned int num)
{
    if (!(num<lst_mg_maillage.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_MAILLAGE* MG_GESTIONNAIRE::get_premier_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
{
    it = lst_mg_maillage.begin();
    if (it == lst_mg_maillage.end())
        return NULL;
    return it->second ;
}

MG_MAILLAGE* MG_GESTIONNAIRE::get_suivant_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
{
    it++;
    if (it==lst_mg_maillage.end())
        return NULL;
    return it->second;
}


unsigned int MG_GESTIONNAIRE::get_nb_mg_maillage(void)
{
    return lst_mg_maillage.size();
}


int MG_GESTIONNAIRE::supprimer_mg_maillageid(unsigned long num)
{
    MG_MAILLAGE* mgmai=get_mg_maillageid(num);
    if (mgmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(num);
    lst_mg_maillage.erase(j);
    delete mgmai;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_maillage(unsigned int num)
{
    MG_MAILLAGE* mgmai=get_mg_maillage(num);
    if (mgmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(id->get_id());
    lst_mg_maillage.erase(j);
    delete mgmai;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_maillage(void)
{
    while (get_nb_mg_maillage()!=0)
    {
        LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.begin();
        MG_MAILLAGE* mgmai=(*j).second;
        MG_IDENTIFICATEUR* id=mgmai;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_maillage.erase(j);
        delete mgmai;
    }

}


// ENTITE FEM_MAILLAGE


int MG_GESTIONNAIRE::ajouter_fem_maillage(FEM_MAILLAGE *femmai)
{
    recherche_bonid(*femmai);
    MG_IDENTIFICATEUR *id=femmai;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,FEM_MAILLAGE*> tmp(femmai->get_id(),femmai);
    lst_fem_maillage.insert(tmp);
    femmai->change_gestionnaire(this);
    return OK;
}


FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillageid(unsigned long num)
{
    LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.find(num);
    if (i==lst_fem_maillage.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillage(unsigned int num)
{
    if (!(num<lst_fem_maillage.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GESTIONNAIRE::get_nb_fem_maillage(void)
{
    return lst_fem_maillage.size();
}


int MG_GESTIONNAIRE::supprimer_fem_maillageid(unsigned long num)
{
    FEM_MAILLAGE* femmai=get_fem_maillageid(num);
    if (femmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=femmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(num);
    lst_fem_maillage.erase(j);
    delete femmai;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_fem_maillage(unsigned int num)
{
    FEM_MAILLAGE* femmai=get_fem_maillage(num);
    if (femmai==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=femmai;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(id->get_id());
    lst_fem_maillage.erase(j);
    delete femmai;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_fem_maillage(void)
{
    while (get_nb_fem_maillage()!=0)
    {
        LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.begin();
        FEM_MAILLAGE* femmai=(*j).second;
        MG_IDENTIFICATEUR* id=femmai;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_fem_maillage.erase(j);
        delete femmai;
    }

}

FEM_MAILLAGE* MG_GESTIONNAIRE::get_premier_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
{
    it = lst_fem_maillage.begin();
    if (it == lst_fem_maillage.end())
        return NULL;
    return it->second ;
}

FEM_MAILLAGE* MG_GESTIONNAIRE::get_suivant_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
{
    it++;
    if (it==lst_fem_maillage.end())
        return NULL;
    return it->second;
}


// ENTITE MG_SOLUTION


int MG_GESTIONNAIRE::ajouter_mg_solution(MG_SOLUTION *mgsol)
{
    recherche_bonid(*mgsol);
    MG_IDENTIFICATEUR *id=mgsol;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,MG_SOLUTION*> tmp(mgsol->get_id(),mgsol);
    lst_mg_solution.insert(tmp);
    return OK;
}


MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solutionid(unsigned long num)
{
    LISTE_MG_SOLUTION::iterator i=lst_mg_solution.find(num);
    if (i==lst_mg_solution.end())
    {
        return NULL;
    }
    return ((*i).second);
}


MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(unsigned int num)
{
    if (!(num<lst_mg_solution.size()))
    {
        return NULL;
    }
    LISTE_MG_SOLUTION::iterator i=lst_mg_solution.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(MG_MAILLAGE* mg,int nb_champs,char *nomfichier,char *nomsolution)
{
 LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
 while (j!=lst_mg_solution.end())
    {
        
        MG_SOLUTION* mgsol=(*j).second;
        if (mgsol->get_maillage()==mg)
          if (mgsol->get_nb_champ()==nb_champs)
            if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
              if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
                return mgsol;
        j++;
    }
    return NULL;
}

MG_SOLUTION* MG_GESTIONNAIRE::get_premier_mg_solution(LISTE_MG_SOLUTION::iterator &it)
{
    it = lst_mg_solution.begin();
    if (it == lst_mg_solution.end())
        return NULL;
    return it->second ;
}

MG_SOLUTION* MG_GESTIONNAIRE::get_suivant_mg_solution(LISTE_MG_SOLUTION::iterator &it)
{
    it++;
    if (it==lst_mg_solution.end())
        return NULL;
    return it->second;
}


unsigned int MG_GESTIONNAIRE::get_nb_mg_solution(void)
{
    return lst_mg_solution.size();
}


int MG_GESTIONNAIRE::supprimer_mg_solutionid(unsigned long num)
{
    MG_SOLUTION* mgsol=get_mg_solutionid(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(num);
    lst_mg_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_mg_solution(unsigned int num)
{
    MG_SOLUTION* mgsol=get_mg_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(id->get_id());
    lst_mg_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_mg_solution(void)
{
    while (get_nb_mg_solution()!=0)
    {
        LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
        MG_SOLUTION* mgsol=(*j).second;
        MG_IDENTIFICATEUR* id=mgsol;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_solution.erase(j);
        delete mgsol;
    }

}


// ENTITE FEM_SOLUTION


int MG_GESTIONNAIRE::ajouter_fem_solution(FEM_SOLUTION *mgsol)
{
    recherche_bonid(*mgsol);
    MG_IDENTIFICATEUR *id=mgsol;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,FEM_SOLUTION*> tmp(mgsol->get_id(),mgsol);
    lst_fem_solution.insert(tmp);
    return OK;
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solutionid(unsigned long num)
{
    LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.find(num);
    if (i==lst_fem_solution.end())
    {
        return NULL;
    }
    return ((*i).second);
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(unsigned int num)
{
    if (!(num<lst_fem_solution.size()))
    {
        return NULL;
    }
    LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(FEM_MAILLAGE* fem,int nb_champs,char *nomfichier,char *nomsolution)
{
 LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
 while (j!=lst_fem_solution.end())
    {
        
        FEM_SOLUTION* mgsol=(*j).second;
        if (mgsol->get_maillage()==fem)
          if (mgsol->get_nb_champ()==nb_champs)
            if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
              if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
                return mgsol;
        j++;
    }
    return NULL;
}


unsigned int MG_GESTIONNAIRE::get_nb_fem_solution(void)
{
    return lst_fem_solution.size();
}


int MG_GESTIONNAIRE::supprimer_fem_solutionid(unsigned long num)
{
    FEM_SOLUTION* mgsol=get_fem_solutionid(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(num);
    lst_fem_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}


int MG_GESTIONNAIRE::supprimer_fem_solution(unsigned int num)
{
    FEM_SOLUTION* mgsol=get_fem_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
    lst_fem_solution.erase(j);
    mgsol->efface();
    delete mgsol;
    return OK;
}

int MG_GESTIONNAIRE::supprimer_fem_solution_du_gestionnaire(unsigned int num)
{
    FEM_SOLUTION* mgsol=get_fem_solution(num);
    if (mgsol==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsol;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
    lst_fem_solution.erase(j);
    return OK;
}


void MG_GESTIONNAIRE::supprimer_tout_fem_solution(void)
{
    while (get_nb_fem_solution()!=0)
    {
        LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
        FEM_SOLUTION* mgsol=(*j).second;
        MG_IDENTIFICATEUR* id=mgsol;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_fem_solution.erase(j);
        delete mgsol;
    }

}


FEM_SOLUTION* MG_GESTIONNAIRE::get_premier_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
{
    it = lst_fem_solution.begin();
    if (it == lst_fem_solution.end())
        return NULL;
    return it->second ;
}

FEM_SOLUTION* MG_GESTIONNAIRE::get_suivant_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
{
    it++;
    if (it==lst_fem_solution.end())
        return NULL;
    return it->second;
}


// FIN DE GESTION DES ENTITES


void MG_GESTIONNAIRE::enregistrer(char* chemin)
{
    std::ofstream o(chemin,std::ios::out|std::ios::trunc);
    o.precision(16);
    o.setf(std::ios::showpoint);
    o <<(*this) << std::endl;
}

void MG_GESTIONNAIRE::enregistrer(const char* chemin)
{
    std::ofstream o(chemin,std::ios::out|std::ios::trunc);
    o.precision(16);
    o.setf(std::ios::showpoint);
    o <<  (*this) << std::endl;
}

void MG_GESTIONNAIRE::enregistrer(std::ostream& o)
{
    LISTE_ENTITE::const_iterator i;
    o << "// Fichier MAGIC - UQTR;" << std::endl;
    o << "//*i:" << entiteidmax << ";" << std::endl;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->enregistrer(o);
    o << "FIN;" << std::endl;
}


#ifdef BREP_SAT
SAT_GESTIONNAIRE&  MG_GESTIONNAIRE::get_gest_sat(void)
{
    return fichsat;
}
#endif
#ifdef BREP_STEP
ST_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_step(void)
{
    return fichstep;
}
#endif

#ifdef BREP_SLD
SLD_FONCTION& MG_GESTIONNAIRE::get_sld_fonction(void)
{
    return *fonction;
}
#endif


#ifdef BREP_OCC
OCC_FONCTION1& MG_GESTIONNAIRE::get_occ_fonction1(void)
{
    return *fonction1;
}
#endif

std::ostream& operator << (std::ostream& o,MG_GESTIONNAIRE& gest)
{
    gest.enregistrer(o);
    return o;
}

Revision:	674
Committed:	Tue Jun 9 18:30:54 2015 UTC (9 years, 11 months ago) by francois
File size:	18814 byte(s)
Log Message:	Transformation d'un support de carte de taille non structure en structure (formule à preciser et a revoir) Calcul du temps CPU pour toutes les applications en incluant le temps CPU de code aster Changement dans la projection et la comparaison de solution pour la generaliser à tous les maillages Divers bug petit sur maillage hex/quadra
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuilli�re et Vincent FRANCOIS
5			// D�partement de G�nie M�canique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du d�partement
8			// de g�nie m�canique de l'Universit� du Qu�bec �
9			// Trois Rivi�res
10			// Les librairies ne peuvent �tre utilis�es sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// mg_gestionnaire.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26
27
28			#include "mg_gestionnaire.h"
29
30
31			#include "sld_fonction.h"
32			#include "occ_fonction1.h"
33
34
35			#include <fstream>
36			//#include "affiche.h"
37			//#include "message.h"
38
39
40			//using namespace std;
41
42			MG_GESTIONNAIRE::MG_GESTIONNAIRE():entiteidmax(0),ouvertsld(0)
43			{
44			#ifdef BREP_SLD
45			fonction=new SLD_FONCTION;
46			#endif
47
48			#ifdef BREP_OCC
49			fonction1=new OCC_FONCTION1;
50			#endif
51
52			}
53
54			MG_GESTIONNAIRE::~MG_GESTIONNAIRE()
55			{
56	francois	674	supprimer_tout_fem_solution();
57	francois	283	supprimer_tout_mg_solution();
58			supprimer_tout_mg_maillage();
59			supprimer_tout_mg_geometrie();
60			#ifdef BREP_SLD
61			delete fonction;
62			#endif
63
64			#ifdef BREP_OCC
65			delete fonction1;
66			#endif
67			}
68
69			void MG_GESTIONNAIRE::recherche_bonid(MG_IDENTIFICATEUR &ident)
70			{
71			if (ident.get_id()==0)
72			{
73			entiteidmax++;
74			ident.change_id(entiteidmax);
75			}
76			else
77			{
78			if (ident.get_id()>entiteidmax) entiteidmax=ident.get_id();
79			}
80			}
81
82			void MG_GESTIONNAIRE::recherche_bonidvisuel(MG_IDENTIFICATEUR &ident)
83			{
84			if (ident.get_id()==0)
85			{
86			entitevisuelidmax++;
87			ident.change_id(entitevisuelidmax);
88			}
89			else
90			{
91			if (ident.get_id()>entitevisuelidmax) entitevisuelidmax=ident.get_id();
92			}
93			}
94
95			// ENTITE MG_GEOMETRIE
96
97
98			int MG_GESTIONNAIRE::ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
99			{
100			recherche_bonid(*mggeo);
101			MG_IDENTIFICATEUR *id=mggeo;
102			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
103			if (!p.second) return FAIL;
104			std::pair<const unsigned long,MG_GEOMETRIE*> tmp(mggeo->get_id(),mggeo);
105			lst_mg_geometrie.insert(tmp);
106			mggeo->change_gestionnaire(this);
107			return OK;
108			}
109
110
111			MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrieid(unsigned long num)
112			{
113			LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.find(num);
114			if (i==lst_mg_geometrie.end())
115			{
116			// afficheur << INEXISTE << enderr;
117			return NULL;
118			}
119			return ((*i).second);
120			}
121
122
123
124			MG_GEOMETRIE* MG_GESTIONNAIRE::get_mg_geometrie(unsigned int num)
125			{
126			if (!(num<lst_mg_geometrie.size()))
127			{
128			// afficheur << INEXISTE << enderr;
129			return NULL;
130			}
131			LISTE_MG_GEOMETRIE::iterator i=lst_mg_geometrie.begin();
132			for (unsigned long j=0;j<num;j++) i++;
133			return ((*i).second);
134			}
135
136			MG_GEOMETRIE* MG_GESTIONNAIRE::get_premier_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
137			{
138			it = lst_mg_geometrie.begin();
139			if (it == lst_mg_geometrie.end())
140			return NULL;
141			return it->second ;
142			}
143
144			MG_GEOMETRIE* MG_GESTIONNAIRE::get_suivant_geometrie(LISTE_MG_GEOMETRIE::iterator &it)
145			{
146			it++;
147			if (it==lst_mg_geometrie.end())
148			return NULL;
149			return it->second;
150			}
151
152			unsigned int MG_GESTIONNAIRE::get_nb_mg_geometrie(void)
153			{
154			return lst_mg_geometrie.size();
155			}
156
157
158			int MG_GESTIONNAIRE::supprimer_mg_geometrieid(unsigned long num)
159			{
160			MG_GEOMETRIE* mggeo=get_mg_geometrieid(num);
161			if (mggeo==NULL)
162			{
163			// afficheur << INEXISTE2 << enderr;
164			return FAIL;
165			}
166			MG_IDENTIFICATEUR* id=mggeo;
167			LISTE_ENTITE::iterator i=lst_entite.find(id);
168			lst_entite.erase(i);
169			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(num);
170			lst_mg_geometrie.erase(j);
171			delete mggeo;
172			return OK;
173			}
174
175
176			int MG_GESTIONNAIRE::supprimer_mg_geometrie(unsigned int num)
177			{
178			MG_GEOMETRIE* mggeo=get_mg_geometrie(num);
179			if (mggeo==NULL)
180			{
181			// afficheur << INEXISTE2 << enderr;
182			return FAIL;
183			}
184			MG_IDENTIFICATEUR* id=mggeo;
185			LISTE_ENTITE::iterator i=lst_entite.find(id);
186			lst_entite.erase(i);
187			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.find(id->get_id());
188			lst_mg_geometrie.erase(j);
189			delete mggeo;
190			return OK;
191			}
192
193
194			void MG_GESTIONNAIRE::supprimer_tout_mg_geometrie(void)
195			{
196			while (get_nb_mg_geometrie()!=0)
197			{
198			LISTE_MG_GEOMETRIE::iterator j=lst_mg_geometrie.begin();
199			MG_GEOMETRIE* mggeo=(*j).second;
200			MG_IDENTIFICATEUR* id=mggeo;
201			LISTE_ENTITE::iterator i=lst_entite.find(id);
202			lst_entite.erase(i);
203			lst_mg_geometrie.erase(j);
204			delete mggeo;
205			}
206			}
207
208			// ENTITE MG_MAILLAGE
209
210
211			int MG_GESTIONNAIRE::ajouter_mg_maillage(MG_MAILLAGE *mgmai)
212			{
213			recherche_bonid(*mgmai);
214			MG_IDENTIFICATEUR *id=mgmai;
215			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
216			if (!p.second)
217			{
218			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
219			return FAIL;
220			}
221
222			std::pair<const unsigned long,MG_MAILLAGE*> tmp(mgmai->get_id(),mgmai);
223			lst_mg_maillage.insert(tmp);
224			mgmai->change_gestionnaire(this);
225			return OK;
226			}
227
228
229			MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillageid(unsigned long num)
230			{
231			LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.find(num);
232			if (i==lst_mg_maillage.end())
233			{
234			// afficheur << INEXISTE << enderr;
235			return NULL;
236			}
237			return ((*i).second);
238			}
239
240
241
242			MG_MAILLAGE* MG_GESTIONNAIRE::get_mg_maillage(unsigned int num)
243			{
244			if (!(num<lst_mg_maillage.size()))
245			{
246			// afficheur << INEXISTE << enderr;
247			return NULL;
248			}
249			LISTE_MG_MAILLAGE::iterator i=lst_mg_maillage.begin();
250			for (unsigned long j=0;j<num;j++) i++;
251			return ((*i).second);
252			}
253
254
255			MG_MAILLAGE* MG_GESTIONNAIRE::get_premier_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
256			{
257			it = lst_mg_maillage.begin();
258			if (it == lst_mg_maillage.end())
259			return NULL;
260			return it->second ;
261			}
262
263			MG_MAILLAGE* MG_GESTIONNAIRE::get_suivant_mg_maillage(LISTE_MG_MAILLAGE::iterator &it)
264			{
265			it++;
266			if (it==lst_mg_maillage.end())
267			return NULL;
268			return it->second;
269			}
270
271
272			unsigned int MG_GESTIONNAIRE::get_nb_mg_maillage(void)
273			{
274			return lst_mg_maillage.size();
275			}
276
277
278			int MG_GESTIONNAIRE::supprimer_mg_maillageid(unsigned long num)
279			{
280			MG_MAILLAGE* mgmai=get_mg_maillageid(num);
281			if (mgmai==NULL)
282			{
283			// afficheur << INEXISTE2 << enderr;
284			return FAIL;
285			}
286			MG_IDENTIFICATEUR* id=mgmai;
287			LISTE_ENTITE::iterator i=lst_entite.find(id);
288			lst_entite.erase(i);
289			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(num);
290			lst_mg_maillage.erase(j);
291			delete mgmai;
292			return OK;
293			}
294
295
296			int MG_GESTIONNAIRE::supprimer_mg_maillage(unsigned int num)
297			{
298			MG_MAILLAGE* mgmai=get_mg_maillage(num);
299			if (mgmai==NULL)
300			{
301			// afficheur << INEXISTE2 << enderr;
302			return FAIL;
303			}
304			MG_IDENTIFICATEUR* id=mgmai;
305			LISTE_ENTITE::iterator i=lst_entite.find(id);
306			lst_entite.erase(i);
307			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.find(id->get_id());
308			lst_mg_maillage.erase(j);
309			delete mgmai;
310			return OK;
311			}
312
313
314			void MG_GESTIONNAIRE::supprimer_tout_mg_maillage(void)
315			{
316			while (get_nb_mg_maillage()!=0)
317			{
318			LISTE_MG_MAILLAGE::iterator j=lst_mg_maillage.begin();
319			MG_MAILLAGE* mgmai=(*j).second;
320			MG_IDENTIFICATEUR* id=mgmai;
321			LISTE_ENTITE::iterator i=lst_entite.find(id);
322			lst_entite.erase(i);
323			lst_mg_maillage.erase(j);
324			delete mgmai;
325			}
326
327			}
328
329
330
331
332			// ENTITE FEM_MAILLAGE
333
334
335
336
337			int MG_GESTIONNAIRE::ajouter_fem_maillage(FEM_MAILLAGE *femmai)
338			{
339			recherche_bonid(*femmai);
340			MG_IDENTIFICATEUR *id=femmai;
341			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
342			if (!p.second)
343			{
344			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
345			return FAIL;
346			}
347
348			std::pair<const unsigned long,FEM_MAILLAGE*> tmp(femmai->get_id(),femmai);
349			lst_fem_maillage.insert(tmp);
350			femmai->change_gestionnaire(this);
351			return OK;
352			}
353
354
355			FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillageid(unsigned long num)
356			{
357			LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.find(num);
358			if (i==lst_fem_maillage.end())
359			{
360			// afficheur << INEXISTE << enderr;
361			return NULL;
362			}
363			return ((*i).second);
364			}
365
366
367
368			FEM_MAILLAGE* MG_GESTIONNAIRE::get_fem_maillage(unsigned int num)
369			{
370			if (!(num<lst_fem_maillage.size()))
371			{
372			// afficheur << INEXISTE << enderr;
373			return NULL;
374			}
375			LISTE_FEM_MAILLAGE::iterator i=lst_fem_maillage.begin();
376			for (unsigned long j=0;j<num;j++) i++;
377			return ((*i).second);
378			}
379
380
381
382			unsigned int MG_GESTIONNAIRE::get_nb_fem_maillage(void)
383			{
384			return lst_fem_maillage.size();
385			}
386
387
388			int MG_GESTIONNAIRE::supprimer_fem_maillageid(unsigned long num)
389			{
390			FEM_MAILLAGE* femmai=get_fem_maillageid(num);
391			if (femmai==NULL)
392			{
393			// afficheur << INEXISTE2 << enderr;
394			return FAIL;
395			}
396			MG_IDENTIFICATEUR* id=femmai;
397			LISTE_ENTITE::iterator i=lst_entite.find(id);
398			lst_entite.erase(i);
399			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(num);
400			lst_fem_maillage.erase(j);
401			delete femmai;
402			return OK;
403			}
404
405
406			int MG_GESTIONNAIRE::supprimer_fem_maillage(unsigned int num)
407			{
408			FEM_MAILLAGE* femmai=get_fem_maillage(num);
409			if (femmai==NULL)
410			{
411			// afficheur << INEXISTE2 << enderr;
412			return FAIL;
413			}
414			MG_IDENTIFICATEUR* id=femmai;
415			LISTE_ENTITE::iterator i=lst_entite.find(id);
416			lst_entite.erase(i);
417			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.find(id->get_id());
418			lst_fem_maillage.erase(j);
419			delete femmai;
420			return OK;
421			}
422
423
424			void MG_GESTIONNAIRE::supprimer_tout_fem_maillage(void)
425			{
426			while (get_nb_fem_maillage()!=0)
427			{
428			LISTE_FEM_MAILLAGE::iterator j=lst_fem_maillage.begin();
429			FEM_MAILLAGE* femmai=(*j).second;
430			MG_IDENTIFICATEUR* id=femmai;
431			LISTE_ENTITE::iterator i=lst_entite.find(id);
432			lst_entite.erase(i);
433			lst_fem_maillage.erase(j);
434			delete femmai;
435			}
436
437			}
438
439			FEM_MAILLAGE* MG_GESTIONNAIRE::get_premier_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
440			{
441			it = lst_fem_maillage.begin();
442			if (it == lst_fem_maillage.end())
443			return NULL;
444			return it->second ;
445			}
446
447			FEM_MAILLAGE* MG_GESTIONNAIRE::get_suivant_fem_maillage(LISTE_FEM_MAILLAGE::iterator &it)
448			{
449			it++;
450			if (it==lst_fem_maillage.end())
451			return NULL;
452			return it->second;
453			}
454
455
456
457
458
459			// ENTITE MG_SOLUTION
460
461
462
463
464
465
466			int MG_GESTIONNAIRE::ajouter_mg_solution(MG_SOLUTION *mgsol)
467			{
468			recherche_bonid(*mgsol);
469			MG_IDENTIFICATEUR *id=mgsol;
470			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
471			if (!p.second)
472			{
473			return FAIL;
474			}
475
476			std::pair<const unsigned long,MG_SOLUTION*> tmp(mgsol->get_id(),mgsol);
477			lst_mg_solution.insert(tmp);
478			return OK;
479			}
480
481
482			MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solutionid(unsigned long num)
483			{
484			LISTE_MG_SOLUTION::iterator i=lst_mg_solution.find(num);
485			if (i==lst_mg_solution.end())
486			{
487			return NULL;
488			}
489			return ((*i).second);
490			}
491
492
493
494			MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(unsigned int num)
495			{
496			if (!(num<lst_mg_solution.size()))
497			{
498			return NULL;
499			}
500			LISTE_MG_SOLUTION::iterator i=lst_mg_solution.begin();
501			for (unsigned long j=0;j<num;j++) i++;
502			return ((*i).second);
503			}
504
505	francois	326	MG_SOLUTION* MG_GESTIONNAIRE::get_mg_solution(MG_MAILLAGE* mg,int nb_champs,char nomfichier,char nomsolution)
506			{
507			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
508			while (j!=lst_mg_solution.end())
509			{
510
511			MG_SOLUTION* mgsol=(*j).second;
512			if (mgsol->get_maillage()==mg)
513			if (mgsol->get_nb_champ()==nb_champs)
514			if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
515			if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
516			return mgsol;
517			j++;
518			}
519			return NULL;
520			}
521	francois	283
522			MG_SOLUTION* MG_GESTIONNAIRE::get_premier_mg_solution(LISTE_MG_SOLUTION::iterator &it)
523			{
524			it = lst_mg_solution.begin();
525			if (it == lst_mg_solution.end())
526			return NULL;
527			return it->second ;
528			}
529
530			MG_SOLUTION* MG_GESTIONNAIRE::get_suivant_mg_solution(LISTE_MG_SOLUTION::iterator &it)
531			{
532			it++;
533			if (it==lst_mg_solution.end())
534			return NULL;
535			return it->second;
536			}
537
538
539			unsigned int MG_GESTIONNAIRE::get_nb_mg_solution(void)
540			{
541			return lst_mg_solution.size();
542			}
543
544
545			int MG_GESTIONNAIRE::supprimer_mg_solutionid(unsigned long num)
546			{
547			MG_SOLUTION* mgsol=get_mg_solutionid(num);
548			if (mgsol==NULL)
549			{
550			return FAIL;
551			}
552			MG_IDENTIFICATEUR* id=mgsol;
553			LISTE_ENTITE::iterator i=lst_entite.find(id);
554			lst_entite.erase(i);
555			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(num);
556			lst_mg_solution.erase(j);
557			mgsol->efface();
558			delete mgsol;
559			return OK;
560			}
561
562
563			int MG_GESTIONNAIRE::supprimer_mg_solution(unsigned int num)
564			{
565			MG_SOLUTION* mgsol=get_mg_solution(num);
566			if (mgsol==NULL)
567			{
568			return FAIL;
569			}
570			MG_IDENTIFICATEUR* id=mgsol;
571			LISTE_ENTITE::iterator i=lst_entite.find(id);
572			lst_entite.erase(i);
573			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.find(id->get_id());
574			lst_mg_solution.erase(j);
575			mgsol->efface();
576			delete mgsol;
577			return OK;
578			}
579
580
581			void MG_GESTIONNAIRE::supprimer_tout_mg_solution(void)
582			{
583			while (get_nb_mg_solution()!=0)
584			{
585			LISTE_MG_SOLUTION::iterator j=lst_mg_solution.begin();
586			MG_SOLUTION* mgsol=(*j).second;
587			MG_IDENTIFICATEUR* id=mgsol;
588			LISTE_ENTITE::iterator i=lst_entite.find(id);
589			lst_entite.erase(i);
590			lst_mg_solution.erase(j);
591			delete mgsol;
592			}
593
594			}
595
596
597
598
599			// ENTITE FEM_SOLUTION
600
601
602
603
604
605			int MG_GESTIONNAIRE::ajouter_fem_solution(FEM_SOLUTION *mgsol)
606			{
607			recherche_bonid(*mgsol);
608			MG_IDENTIFICATEUR *id=mgsol;
609			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
610			if (!p.second)
611			{
612			return FAIL;
613			}
614
615			std::pair<const unsigned long,FEM_SOLUTION*> tmp(mgsol->get_id(),mgsol);
616			lst_fem_solution.insert(tmp);
617			return OK;
618			}
619
620
621			FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solutionid(unsigned long num)
622			{
623			LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.find(num);
624			if (i==lst_fem_solution.end())
625			{
626			return NULL;
627			}
628			return ((*i).second);
629			}
630
631
632
633			FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(unsigned int num)
634			{
635			if (!(num<lst_fem_solution.size()))
636			{
637			return NULL;
638			}
639			LISTE_FEM_SOLUTION::iterator i=lst_fem_solution.begin();
640			for (unsigned long j=0;j<num;j++) i++;
641			return ((*i).second);
642			}
643
644
645	francois	326	FEM_SOLUTION* MG_GESTIONNAIRE::get_fem_solution(FEM_MAILLAGE* fem,int nb_champs,char nomfichier,char nomsolution)
646			{
647			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
648			while (j!=lst_fem_solution.end())
649			{
650
651			FEM_SOLUTION* mgsol=(*j).second;
652			if (mgsol->get_maillage()==fem)
653			if (mgsol->get_nb_champ()==nb_champs)
654			if (strcmp(mgsol->get_nom().c_str(),nomsolution)==0)
655			if (strcmp(mgsol->get_nom_fichier().c_str(),nomfichier)==0)
656			return mgsol;
657			j++;
658			}
659			return NULL;
660			}
661	francois	283
662	francois	326
663	francois	283	unsigned int MG_GESTIONNAIRE::get_nb_fem_solution(void)
664			{
665			return lst_fem_solution.size();
666			}
667
668
669			int MG_GESTIONNAIRE::supprimer_fem_solutionid(unsigned long num)
670			{
671			FEM_SOLUTION* mgsol=get_fem_solutionid(num);
672			if (mgsol==NULL)
673			{
674			return FAIL;
675			}
676			MG_IDENTIFICATEUR* id=mgsol;
677			LISTE_ENTITE::iterator i=lst_entite.find(id);
678			lst_entite.erase(i);
679			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(num);
680			lst_fem_solution.erase(j);
681			mgsol->efface();
682			delete mgsol;
683			return OK;
684			}
685
686
687			int MG_GESTIONNAIRE::supprimer_fem_solution(unsigned int num)
688			{
689			FEM_SOLUTION* mgsol=get_fem_solution(num);
690			if (mgsol==NULL)
691			{
692			return FAIL;
693			}
694			MG_IDENTIFICATEUR* id=mgsol;
695			LISTE_ENTITE::iterator i=lst_entite.find(id);
696			lst_entite.erase(i);
697			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
698			lst_fem_solution.erase(j);
699			mgsol->efface();
700			delete mgsol;
701			return OK;
702			}
703
704			int MG_GESTIONNAIRE::supprimer_fem_solution_du_gestionnaire(unsigned int num)
705			{
706			FEM_SOLUTION* mgsol=get_fem_solution(num);
707			if (mgsol==NULL)
708			{
709			return FAIL;
710			}
711			MG_IDENTIFICATEUR* id=mgsol;
712			LISTE_ENTITE::iterator i=lst_entite.find(id);
713			lst_entite.erase(i);
714			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.find(id->get_id());
715			lst_fem_solution.erase(j);
716			return OK;
717			}
718
719
720			void MG_GESTIONNAIRE::supprimer_tout_fem_solution(void)
721			{
722			while (get_nb_fem_solution()!=0)
723			{
724			LISTE_FEM_SOLUTION::iterator j=lst_fem_solution.begin();
725			FEM_SOLUTION* mgsol=(*j).second;
726			MG_IDENTIFICATEUR* id=mgsol;
727			LISTE_ENTITE::iterator i=lst_entite.find(id);
728			lst_entite.erase(i);
729			lst_fem_solution.erase(j);
730			delete mgsol;
731			}
732
733			}
734
735
736			FEM_SOLUTION* MG_GESTIONNAIRE::get_premier_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
737			{
738			it = lst_fem_solution.begin();
739			if (it == lst_fem_solution.end())
740			return NULL;
741			return it->second ;
742			}
743
744			FEM_SOLUTION* MG_GESTIONNAIRE::get_suivant_fem_solution(LISTE_FEM_SOLUTION::iterator &it)
745			{
746			it++;
747			if (it==lst_fem_solution.end())
748			return NULL;
749			return it->second;
750			}
751
752
753
754			// FIN DE GESTION DES ENTITES
755
756
757
758			void MG_GESTIONNAIRE::enregistrer(char* chemin)
759			{
760			std::ofstream o(chemin,std::ios::out\|std::ios::trunc);
761			o.precision(16);
762			o.setf(std::ios::showpoint);
763			o <<(*this) << std::endl;
764			}
765
766			void MG_GESTIONNAIRE::enregistrer(const char* chemin)
767			{
768			std::ofstream o(chemin,std::ios::out\|std::ios::trunc);
769			o.precision(16);
770			o.setf(std::ios::showpoint);
771			o << (*this) << std::endl;
772			}
773
774			void MG_GESTIONNAIRE::enregistrer(std::ostream& o)
775			{
776			LISTE_ENTITE::const_iterator i;
777			o << "// Fichier MAGIC - UQTR;" << std::endl;
778			o << "//*i:" << entiteidmax << ";" << std::endl;
779			for (i=lst_entite.begin();i!=lst_entite.end();i++)
780			(*i)->enregistrer(o);
781			o << "FIN;" << std::endl;
782			}
783
784
785			#ifdef BREP_SAT
786			SAT_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_sat(void)
787			{
788			return fichsat;
789			}
790			#endif
791			#ifdef BREP_STEP
792			ST_GESTIONNAIRE& MG_GESTIONNAIRE::get_gest_step(void)
793			{
794			return fichstep;
795			}
796			#endif
797
798			#ifdef BREP_SLD
799			SLD_FONCTION& MG_GESTIONNAIRE::get_sld_fonction(void)
800			{
801			return *fonction;
802			}
803			#endif
804
805
806			#ifdef BREP_OCC
807			OCC_FONCTION1& MG_GESTIONNAIRE::get_occ_fonction1(void)
808			{
809			return *fonction1;
810			}
811			#endif
812
813			std::ostream& operator << (std::ostream& o,MG_GESTIONNAIRE& gest)
814			{
815			gest.enregistrer(o);
816			return o;
817			}
818